public static async Task CreateChannel(RPCClient cashCow, ILightningClient sender, ILightningClient dest)
        {
            var destInfo = await dest.GetInfo();

            var destInvoice = await dest.CreateInvoice(1000, "EnsureConnectedToDestination", TimeSpan.FromSeconds(5000));

            while (true)
            {
                var result = await sender.Pay(destInvoice.BOLT11);

                if (result.Result == PayResult.CouldNotFindRoute)
                {
                    var openChannel = await sender.OpenChannel(new OpenChannelRequest()
                    {
                        NodeInfo      = destInfo.NodeInfoList[0],
                        ChannelAmount = Money.Satoshis(16777215),
                        FeeRate       = new FeeRate(1UL, 1)
                    });

                    if (openChannel.Result == OpenChannelResult.CannotAffordFunding)
                    {
                        var address = await sender.GetDepositAddress();

                        try
                        {
                            await cashCow.SendToAddressAsync(address, Money.Coins(1.0m), null, null, true);
                        }
                        catch (RPCException ex) when(ex.RPCCode == RPCErrorCode.RPC_WALLET_INSUFFICIENT_FUNDS || ex.RPCCode == RPCErrorCode.RPC_WALLET_ERROR)
                        {
                            await cashCow.GenerateAsync(1);

                            await cashCow.SendToAddressAsync(address, Money.Coins(1.0m), null, null, true);
                        }
                        await cashCow.GenerateAsync(10);
                        await WaitLNSynched(cashCow, sender);
                        await WaitLNSynched(cashCow, dest);
                    }
                    if (openChannel.Result == OpenChannelResult.PeerNotConnected)
                    {
                        await sender.ConnectTo(destInfo.NodeInfoList[0]);
                    }
                    if (openChannel.Result == OpenChannelResult.NeedMoreConf)
                    {
                        await cashCow.GenerateAsync(6);
                        await WaitLNSynched(cashCow, sender);
                        await WaitLNSynched(cashCow, dest);
                    }
                    if (openChannel.Result == OpenChannelResult.AlreadyExists)
                    {
                        await Task.Delay(1000);
                    }
                }
                else if (result.Result == PayResult.Ok)
                {
                    break;
                }
            }
        }
示例#2
0
    //we group per store and init the transfers by each
    async Task <bool> TrypayBolt(ILightningClient lightningClient, PayoutBlob payoutBlob, PayoutData payoutData,
                                 BOLT11PaymentRequest bolt11PaymentRequest)
    {
        var boltAmount = bolt11PaymentRequest.MinimumAmount.ToDecimal(LightMoneyUnit.BTC);

        if (boltAmount != payoutBlob.CryptoAmount)
        {
            return(false);
        }

        var result = await lightningClient.Pay(bolt11PaymentRequest.ToString());

        return(result.Result == PayResult.Ok);
    }
示例#3
0
        private static async Task <PayResponse> Pay(ILightningClient sender, string payreq)
        {
            using (var cts = new CancellationTokenSource(5000))
            {
retry:
                try
                {
                    return(await sender.Pay(payreq));
                }
                catch (CLightning.LightningRPCException ex) when(ex.Message.Contains("WIRE_INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS") &&
                                                                 !cts.IsCancellationRequested)
                {
                    await Task.Delay(500);

                    goto retry;
                }
            }
        }
示例#4
0
        public static async Task <ResultVM> TrypayBolt(ILightningClient lightningClient, PayoutBlob payoutBlob, PayoutData payoutData, BOLT11PaymentRequest bolt11PaymentRequest, PaymentMethodId pmi)
        {
            var boltAmount = bolt11PaymentRequest.MinimumAmount.ToDecimal(LightMoneyUnit.BTC);

            if (boltAmount != payoutBlob.CryptoAmount)
            {
                return(new ResultVM
                {
                    PayoutId = payoutData.Id,
                    Result = PayResult.Error,
                    Message = $"The BOLT11 invoice amount ({boltAmount} {pmi.CryptoCode}) did not match the payout's amount ({payoutBlob.CryptoAmount.GetValueOrDefault()} {pmi.CryptoCode})",
                    Destination = payoutBlob.Destination
                });
            }
            var result = await lightningClient.Pay(bolt11PaymentRequest.ToString(), new PayInvoiceParams());

            if (result.Result == PayResult.Ok)
            {
                var message = result.Details?.TotalAmount != null
                    ? $"Paid out {result.Details.TotalAmount.ToDecimal(LightMoneyUnit.BTC)}"
                    : null;
                payoutData.State = PayoutState.Completed;
                return(new ResultVM
                {
                    PayoutId = payoutData.Id,
                    Result = result.Result,
                    Destination = payoutBlob.Destination,
                    Message = message
                });
            }

            return(new ResultVM
            {
                PayoutId = payoutData.Id,
                Result = result.Result,
                Destination = payoutBlob.Destination,
                Message = result.ErrorDetail
            });
        }