Esempio n. 1
0
        protected override async Task <TypedActionHandlerResult <LightningNodeInformation> > Execute(
            Dictionary <string, object> data, RecipeAction recipeAction,
            GetLightningNodeInfoData actionData)
        {
            using (var serviceScope = DependencyHelper.ServiceScopeFactory.CreateScope())
            {
                var externalService = await recipeAction.GetExternalService();

                var service = new LightningNodeService(externalService,
                                                       serviceScope.ServiceProvider.GetService <NBXplorerClientProvider>(),
                                                       serviceScope.ServiceProvider.GetService <NBXplorerSummaryProvider>(),
                                                       serviceScope.ServiceProvider.GetService <SocketFactory>()
                                                       );

                var client = service.ConstructClient();
                var result = await client.GetInfo();

                return(new TypedActionHandlerResult <LightningNodeInformation>()
                {
                    Executed = true,
                    Result =
                        $"Got lightning node info block height:{result.BlockHeight}, node: {result.NodeInfoList.First()}",
                    TypedData = result
                });
            }
        }
        protected override async Task <TypedActionHandlerResult <LightningInvoice> > Execute(Dictionary <string, object> data, RecipeAction recipeAction,
                                                                                             CreateBolt11InvoiceData actionData)
        {
            using (var serviceScope = DependencyHelper.ServiceScopeFactory.CreateScope())
            {
                var externalService = await recipeAction.GetExternalService();

                var service = new LightningNodeService(externalService,
                                                       serviceScope.ServiceProvider.GetService <NBXplorerClientProvider>(),
                                                       serviceScope.ServiceProvider.GetService <NBXplorerSummaryProvider>(),
                                                       serviceScope.ServiceProvider.GetService <SocketFactory>()
                                                       );

                var client  = service.ConstructClient();
                var invoice = await client.CreateInvoice(
                    LightMoney.FromUnit(decimal.Parse(InterpolateString(actionData.Amount, data)),
                                        actionData.AmountMoneyUnit),
                    InterpolateString(actionData.Description, data),
                    TimeSpan.FromMilliseconds(int.Parse(InterpolateString(actionData.ExpiryMilliseconds, data))));

                return(new TypedActionHandlerResult <LightningInvoice>()
                {
                    Executed = true,
                    Result =
                        $"Created Bolt11 invoice {invoice.BOLT11}",
                    TypedData = invoice
                });
            }
        }
        protected override async Task <TypedActionHandlerResult <LightningChannel[]> > Execute(
            Dictionary <string, object> data, RecipeAction recipeAction,
            GetLightningChannelsData actionData)
        {
            using (var serviceScope = DependencyHelper.ServiceScopeFactory.CreateScope())
            {
                var externalService = await recipeAction.GetExternalService();

                var service = new LightningNodeService(externalService,
                                                       serviceScope.ServiceProvider.GetService <NBXplorerClientProvider>(),
                                                       serviceScope.ServiceProvider.GetService <NBXplorerSummaryProvider>(),
                                                       serviceScope.ServiceProvider.GetService <SocketFactory>()
                                                       );

                var client = service.ConstructClient();
                var result = await client.ListChannels();

                return(new TypedActionHandlerResult <LightningChannel[]>()
                {
                    Executed = true,
                    Result =
                        $"Found {result.Length} channels",
                    TypedData = result
                });
            }
        }
        protected override async Task <TypedActionHandlerResult <PayResponse> > Execute(
            Dictionary <string, object> data, RecipeAction recipeAction,
            PayBolt11InvoiceData actionData)
        {
            using (var serviceScope = DependencyHelper.ServiceScopeFactory.CreateScope())
            {
                var externalService = await recipeAction.GetExternalService();

                var service = new LightningNodeService(externalService,
                                                       serviceScope.ServiceProvider.GetService <NBXplorerClientProvider>(),
                                                       serviceScope.ServiceProvider.GetService <NBXplorerSummaryProvider>(),
                                                       serviceScope.ServiceProvider.GetService <SocketFactory>()
                                                       );

                var client   = service.ConstructClient();
                var response = await client.Pay(InterpolateString(actionData.Bolt11, data));

                return(new TypedActionHandlerResult <PayResponse>()
                {
                    Executed = response.Result == PayResult.Ok,
                    Result =
                        $"Paying Bolt11 Invoice: {Enum.GetName(typeof(PayResult), response.Result)}",
                    TypedData = response
                });
            }
        }
Esempio n. 5
0
        protected override async Task <TypedActionHandlerResult <BitcoinAddress> > Execute(
            Dictionary <string, object> data, RecipeAction recipeAction,
            GetOnChainLightningDepositAddressData actionData)
        {
            using (var serviceScope = DependencyHelper.ServiceScopeFactory.CreateScope())
            {
                var externalService = await recipeAction.GetExternalService();

                var service = new LightningNodeService(externalService,
                                                       serviceScope.ServiceProvider.GetService <NBXplorerClientProvider>(),
                                                       serviceScope.ServiceProvider.GetService <NBXplorerSummaryProvider>(),
                                                       serviceScope.ServiceProvider.GetService <SocketFactory>()
                                                       );

                var client = service.ConstructClient();
                var result = await client.GetDepositAddress();

                return(new TypedActionHandlerResult <BitcoinAddress>()
                {
                    Executed = true,
                    Result =
                        $"Got deposit address {result}",
                    TypedData = result
                });
            }
        }
Esempio n. 6
0
        protected override async Task <TypedActionHandlerResult <OpenChannelResponse> > Execute(Dictionary <string, object> data, RecipeAction recipeAction,
                                                                                                OpenLightningChannelData actionData)
        {
            using (var serviceScope = DependencyHelper.ServiceScopeFactory.CreateScope())
            {
                var externalService = await recipeAction.GetExternalService();

                var service = new LightningNodeService(externalService,
                                                       serviceScope.ServiceProvider.GetService <NBXplorerClientProvider>(),
                                                       serviceScope.ServiceProvider.GetService <NBXplorerSummaryProvider>(),
                                                       serviceScope.ServiceProvider.GetService <SocketFactory>()
                                                       );

                var client = service.ConstructClient();
                if (!NodeInfo.TryParse(InterpolateString(actionData.NodeInfo, data),
                                       out var nodeInfo))
                {
                    return(new TypedActionHandlerResult <OpenChannelResponse>()
                    {
                        Executed = false,
                        Result =
                            $"Could not open channel because node info was incorrect",
                    });
                }

                var result = await client.OpenChannel(new OpenChannelRequest()
                {
                    NodeInfo      = nodeInfo,
                    ChannelAmount = Money.FromUnit(decimal.Parse(InterpolateString(actionData.Amount, data)),
                                                   actionData.AmountMoneyUnit)
                });

                return(new TypedActionHandlerResult <OpenChannelResponse>()
                {
                    Executed = result.Result == OpenChannelResult.Ok,
                    Result =
                        $"Open LN Channel with response {Enum.GetName(typeof(OpenChannelResult), result.Result)}",
                    TypedData = result
                });
            }
        }
Esempio n. 7
0
        protected override async Task <TypedActionHandlerResult <NodeInfo> > Execute(
            Dictionary <string, object> data, RecipeAction recipeAction,
            ConnectToLightningNodeData actionData)
        {
            using (var serviceScope = DependencyHelper.ServiceScopeFactory.CreateScope())
            {
                var externalService = await recipeAction.GetExternalService();

                var service = new LightningNodeService(externalService,
                                                       serviceScope.ServiceProvider.GetService <NBXplorerClientProvider>(),
                                                       serviceScope.ServiceProvider.GetService <NBXplorerSummaryProvider>(),
                                                       serviceScope.ServiceProvider.GetService <SocketFactory>()
                                                       );

                var client = service.ConstructClient();

                if (!NodeInfo.TryParse(InterpolateString(actionData.NodeInfo, data),
                                       out var nodeInfo))
                {
                    return(new TypedActionHandlerResult <NodeInfo>()
                    {
                        Executed = false,
                        Result =
                            $"Could not connect because node info was incorrect",
                    });
                }

                await client.ConnectTo(nodeInfo);

                return(new TypedActionHandlerResult <NodeInfo>()
                {
                    Executed = true,
                    Result =
                        $"Connected to LN Node {nodeInfo}",
                    TypedData = nodeInfo
                });
            }
        }