mirror of
https://github.com/aljazceru/lspd.git
synced 2025-12-18 14:24:21 +01:00
298 lines
9.8 KiB
Go
298 lines
9.8 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"log"
|
|
"math/big"
|
|
"os"
|
|
"time"
|
|
|
|
"github.com/btcsuite/btcd/btcec/v2"
|
|
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
|
"github.com/btcsuite/btcd/wire"
|
|
"github.com/lightningnetwork/lnd/lnrpc"
|
|
"github.com/lightningnetwork/lnd/lnrpc/routerrpc"
|
|
"github.com/lightningnetwork/lnd/lnwire"
|
|
"github.com/lightningnetwork/lnd/record"
|
|
"github.com/lightningnetwork/lnd/routing/route"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/metadata"
|
|
"google.golang.org/grpc/status"
|
|
|
|
sphinx "github.com/lightningnetwork/lightning-onion"
|
|
)
|
|
|
|
func checkPayment(incomingAmountMsat, outgoingAmountMsat int64) error {
|
|
fees := incomingAmountMsat * channelFeePermyriad / 10_000 / 1_000 * 1_000
|
|
if fees < channelMinimumFeeMsat {
|
|
fees = channelMinimumFeeMsat
|
|
}
|
|
if incomingAmountMsat-outgoingAmountMsat < fees {
|
|
return fmt.Errorf("not enough fees")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func isConnected(ctx context.Context, client lnrpc.LightningClient, destination []byte) error {
|
|
pubKey := hex.EncodeToString(destination)
|
|
r, err := client.ListPeers(ctx, &lnrpc.ListPeersRequest{LatestError: true})
|
|
if err != nil {
|
|
log.Printf("client.ListPeers() error: %v", err)
|
|
return fmt.Errorf("client.ListPeers() error: %w", err)
|
|
}
|
|
for _, peer := range r.Peers {
|
|
if pubKey == peer.PubKey {
|
|
log.Printf("destination online: %x", destination)
|
|
return nil
|
|
}
|
|
}
|
|
log.Printf("destination offline: %x", destination)
|
|
return fmt.Errorf("destination offline")
|
|
}
|
|
|
|
func openChannel(ctx context.Context, client lnrpc.LightningClient, paymentHash, destination []byte, incomingAmountMsat int64) ([]byte, uint32, error) {
|
|
capacity := incomingAmountMsat/1000 + additionalChannelCapacity
|
|
if capacity == publicChannelAmount {
|
|
capacity++
|
|
}
|
|
channelPoint, err := client.OpenChannelSync(ctx, &lnrpc.OpenChannelRequest{
|
|
NodePubkey: destination,
|
|
LocalFundingAmount: capacity,
|
|
TargetConf: 6,
|
|
Private: true,
|
|
})
|
|
if err != nil {
|
|
log.Printf("client.OpenChannelSync(%x, %v) error: %v", destination, capacity, err)
|
|
return nil, 0, err
|
|
}
|
|
sendOpenChannelEmailNotification(
|
|
paymentHash,
|
|
incomingAmountMsat,
|
|
destination,
|
|
capacity,
|
|
channelPoint.GetFundingTxidBytes(),
|
|
channelPoint.OutputIndex,
|
|
)
|
|
err = setFundingTx(paymentHash, channelPoint.GetFundingTxidBytes(), int(channelPoint.OutputIndex))
|
|
return channelPoint.GetFundingTxidBytes(), channelPoint.OutputIndex, err
|
|
}
|
|
|
|
func getChannel(ctx context.Context, client lnrpc.LightningClient, node []byte, channelPoint string) uint64 {
|
|
r, err := client.ListChannels(ctx, &lnrpc.ListChannelsRequest{Peer: node})
|
|
if err != nil {
|
|
log.Printf("client.ListChannels(%x) error: %v", node, err)
|
|
return 0
|
|
}
|
|
for _, c := range r.Channels {
|
|
log.Printf("getChannel(%x): %v", node, c.ChanId)
|
|
if c.ChannelPoint == channelPoint && c.Active {
|
|
return c.ChanId
|
|
}
|
|
}
|
|
log.Printf("No channel found: getChannel(%x)", node)
|
|
return 0
|
|
}
|
|
|
|
func failForwardSend(interceptorClient routerrpc.Router_HtlcInterceptorClient, incomingCircuitKey *routerrpc.CircuitKey) {
|
|
interceptorClient.Send(&routerrpc.ForwardHtlcInterceptResponse{
|
|
IncomingCircuitKey: incomingCircuitKey,
|
|
Action: routerrpc.ResolveHoldForwardAction_FAIL,
|
|
})
|
|
}
|
|
|
|
func intercept() {
|
|
for {
|
|
cancellableCtx, cancel := context.WithCancel(context.Background())
|
|
clientCtx := metadata.AppendToOutgoingContext(cancellableCtx, "macaroon", os.Getenv("LND_MACAROON_HEX"))
|
|
interceptorClient, err := routerClient.HtlcInterceptor(clientCtx)
|
|
if err != nil {
|
|
log.Printf("routerClient.HtlcInterceptor(): %v", err)
|
|
cancel()
|
|
time.Sleep(1 * time.Second)
|
|
continue
|
|
}
|
|
|
|
for {
|
|
request, err := interceptorClient.Recv()
|
|
if err != nil {
|
|
// If it is just the error result of the context cancellation
|
|
// the we exit silently.
|
|
status, ok := status.FromError(err)
|
|
if ok && status.Code() == codes.Canceled {
|
|
break
|
|
}
|
|
// Otherwise it an unexpected error, we fail the test.
|
|
log.Printf("unexpected error in interceptor.Recv() %v", err)
|
|
cancel()
|
|
break
|
|
}
|
|
fmt.Printf("htlc: %v\nchanID: %v\nincoming amount: %v\noutgoing amount: %v\nincomin expiry: %v\noutgoing expiry: %v\npaymentHash: %x\nonionBlob: %x\n\n",
|
|
request.IncomingCircuitKey.HtlcId,
|
|
request.IncomingCircuitKey.ChanId,
|
|
request.IncomingAmountMsat,
|
|
request.OutgoingAmountMsat,
|
|
request.IncomingExpiry,
|
|
request.OutgoingExpiry,
|
|
request.PaymentHash,
|
|
request.OnionBlob,
|
|
)
|
|
|
|
paymentHash, paymentSecret, destination, incomingAmountMsat, outgoingAmountMsat, fundingTxID, fundingTxOutnum, err := paymentInfo(request.PaymentHash)
|
|
if err != nil {
|
|
log.Printf("paymentInfo(%x) error: %v", request.PaymentHash, err)
|
|
failForwardSend(interceptorClient, request.IncomingCircuitKey)
|
|
continue
|
|
}
|
|
log.Printf("paymentHash:%x\npaymentSecret:%x\ndestination:%x\nincomingAmountMsat:%v\noutgoingAmountMsat:%v\n\n",
|
|
paymentHash, paymentSecret, destination, incomingAmountMsat, outgoingAmountMsat)
|
|
if paymentSecret != nil {
|
|
|
|
if fundingTxID == nil {
|
|
if bytes.Compare(paymentHash, request.PaymentHash) == 0 {
|
|
fundingTxID, fundingTxOutnum, err = openChannel(clientCtx, client, request.PaymentHash, destination, incomingAmountMsat)
|
|
log.Printf("openChannel(%x, %v) err: %v", destination, incomingAmountMsat, err)
|
|
if err != nil {
|
|
failForwardSend(interceptorClient, request.IncomingCircuitKey)
|
|
continue
|
|
}
|
|
} else { //probing
|
|
failureCode := lnrpc.Failure_TEMPORARY_CHANNEL_FAILURE
|
|
if err := isConnected(clientCtx, client, destination); err == nil {
|
|
failureCode = lnrpc.Failure_INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS
|
|
}
|
|
interceptorClient.Send(&routerrpc.ForwardHtlcInterceptResponse{
|
|
IncomingCircuitKey: request.IncomingCircuitKey,
|
|
Action: routerrpc.ResolveHoldForwardAction_FAIL,
|
|
FailureCode: failureCode,
|
|
})
|
|
continue
|
|
}
|
|
}
|
|
|
|
pubKey, err := btcec.ParsePubKey(destination)
|
|
if err != nil {
|
|
log.Printf("btcec.ParsePubKey(%x): %v", destination, err)
|
|
failForwardSend(interceptorClient, request.IncomingCircuitKey)
|
|
continue
|
|
}
|
|
|
|
sessionKey, err := btcec.NewPrivateKey()
|
|
if err != nil {
|
|
log.Printf("btcec.NewPrivateKey(): %v", err)
|
|
failForwardSend(interceptorClient, request.IncomingCircuitKey)
|
|
continue
|
|
}
|
|
|
|
var bigProd, bigAmt big.Int
|
|
amt := (bigAmt.Div(bigProd.Mul(big.NewInt(outgoingAmountMsat), big.NewInt(int64(request.OutgoingAmountMsat))), big.NewInt(incomingAmountMsat))).Int64()
|
|
|
|
var addr [32]byte
|
|
copy(addr[:], paymentSecret)
|
|
hop := route.Hop{
|
|
AmtToForward: lnwire.MilliSatoshi(amt),
|
|
OutgoingTimeLock: request.OutgoingExpiry,
|
|
MPP: record.NewMPP(lnwire.MilliSatoshi(outgoingAmountMsat), addr),
|
|
CustomRecords: make(record.CustomSet),
|
|
}
|
|
|
|
var b bytes.Buffer
|
|
err = hop.PackHopPayload(&b, uint64(0))
|
|
if err != nil {
|
|
log.Printf("hop.PackHopPayload(): %v", err)
|
|
failForwardSend(interceptorClient, request.IncomingCircuitKey)
|
|
continue
|
|
}
|
|
|
|
payload, err := sphinx.NewHopPayload(nil, b.Bytes())
|
|
if err != nil {
|
|
log.Printf("sphinx.NewHopPayload(): %v", err)
|
|
failForwardSend(interceptorClient, request.IncomingCircuitKey)
|
|
continue
|
|
}
|
|
|
|
var sphinxPath sphinx.PaymentPath
|
|
sphinxPath[0] = sphinx.OnionHop{
|
|
NodePub: *pubKey,
|
|
HopPayload: payload,
|
|
}
|
|
sphinxPacket, err := sphinx.NewOnionPacket(
|
|
&sphinxPath, sessionKey, request.PaymentHash,
|
|
sphinx.DeterministicPacketFiller,
|
|
)
|
|
if err != nil {
|
|
log.Printf("sphinx.NewOnionPacket(): %v", err)
|
|
failForwardSend(interceptorClient, request.IncomingCircuitKey)
|
|
continue
|
|
}
|
|
var onionBlob bytes.Buffer
|
|
err = sphinxPacket.Encode(&onionBlob)
|
|
if err != nil {
|
|
log.Printf("sphinxPacket.Encode(): %v", err)
|
|
failForwardSend(interceptorClient, request.IncomingCircuitKey)
|
|
continue
|
|
}
|
|
var h chainhash.Hash
|
|
err = h.SetBytes(fundingTxID)
|
|
if err != nil {
|
|
log.Printf("h.SetBytes(%x) error: %v", fundingTxID, err)
|
|
failForwardSend(interceptorClient, request.IncomingCircuitKey)
|
|
continue
|
|
}
|
|
channelPoint := wire.NewOutPoint(&h, fundingTxOutnum).String()
|
|
go resumeOrCancel(
|
|
clientCtx, interceptorClient, request.IncomingCircuitKey, destination,
|
|
channelPoint, uint64(amt), onionBlob.Bytes(),
|
|
)
|
|
|
|
} else {
|
|
interceptorClient.Send(&routerrpc.ForwardHtlcInterceptResponse{
|
|
IncomingCircuitKey: request.IncomingCircuitKey,
|
|
Action: routerrpc.ResolveHoldForwardAction_RESUME,
|
|
OutgoingAmountMsat: request.OutgoingAmountMsat,
|
|
OutgoingRequestedChanId: request.OutgoingRequestedChanId,
|
|
OnionBlob: request.OnionBlob,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func resumeOrCancel(
|
|
ctx context.Context,
|
|
interceptorClient routerrpc.Router_HtlcInterceptorClient,
|
|
incomingCircuitKey *routerrpc.CircuitKey,
|
|
destination []byte,
|
|
channelPoint string,
|
|
outgoingAmountMsat uint64,
|
|
onionBlob []byte,
|
|
) {
|
|
deadline := time.Now().Add(10 * time.Second)
|
|
for {
|
|
chanID := getChannel(ctx, client, destination, channelPoint)
|
|
if chanID != 0 {
|
|
interceptorClient.Send(&routerrpc.ForwardHtlcInterceptResponse{
|
|
IncomingCircuitKey: incomingCircuitKey,
|
|
Action: routerrpc.ResolveHoldForwardAction_RESUME,
|
|
OutgoingAmountMsat: outgoingAmountMsat,
|
|
OutgoingRequestedChanId: chanID,
|
|
OnionBlob: onionBlob,
|
|
})
|
|
err := insertChannel(chanID, channelPoint, destination, time.Now())
|
|
if err != nil {
|
|
log.Printf("insertChannel error: %v", err)
|
|
}
|
|
return
|
|
}
|
|
log.Printf("getChannel(%x, %v) returns 0", destination, channelPoint)
|
|
if time.Now().After(deadline) {
|
|
log.Printf("Stop retrying getChannel(%x, %v)", destination, channelPoint)
|
|
break
|
|
}
|
|
time.Sleep(1 * time.Second)
|
|
}
|
|
failForwardSend(interceptorClient, incomingCircuitKey)
|
|
}
|