package routerrpc import ( "context" "crypto/rand" "encoding/hex" "errors" "fmt" math "math" "time" "github.com/btcsuite/btcd/btcec" "github.com/btcsuite/btcd/chaincfg" "github.com/btcsuite/btcd/wire" "github.com/btcsuite/btcutil" "github.com/lightningnetwork/lnd/channeldb" "github.com/lightningnetwork/lnd/feature" "github.com/lightningnetwork/lnd/htlcswitch" "github.com/lightningnetwork/lnd/lnrpc" "github.com/lightningnetwork/lnd/lntypes" "github.com/lightningnetwork/lnd/lnwire" "github.com/lightningnetwork/lnd/record" "github.com/lightningnetwork/lnd/routing" "github.com/lightningnetwork/lnd/routing/route" "github.com/lightningnetwork/lnd/subscribe" "github.com/lightningnetwork/lnd/zpay32" ) const ( // DefaultMaxParts is the default number of splits we'll possibly use // for MPP when the user is attempting to send a payment. // // TODO(roasbeef): make this value dynamic based on expected number of // attempts for given amount DefaultMaxParts = 16 ) // RouterBackend contains the backend implementation of the router rpc sub // server calls. type RouterBackend struct { // SelfNode is the vertex of the node sending the payment. SelfNode route.Vertex // FetchChannelCapacity is a closure that we'll use the fetch the total // capacity of a channel to populate in responses. FetchChannelCapacity func(chanID uint64) (btcutil.Amount, error) // FetchChannelEndpoints returns the pubkeys of both endpoints of the // given channel id. FetchChannelEndpoints func(chanID uint64) (route.Vertex, route.Vertex, error) // FindRoutes is a closure that abstracts away how we locate/query for // routes. FindRoute func(source, target route.Vertex, amt lnwire.MilliSatoshi, restrictions *routing.RestrictParams, destCustomRecords record.CustomSet, routeHints map[route.Vertex][]*channeldb.ChannelEdgePolicy, finalExpiry uint16) (*route.Route, error) MissionControl MissionControl // ActiveNetParams are the network parameters of the primary network // that the route is operating on. This is necessary so we can ensure // that we receive payment requests that send to destinations on our // network. ActiveNetParams *chaincfg.Params // Tower is the ControlTower instance that is used to track pending // payments. Tower routing.ControlTower // MaxTotalTimelock is the maximum total time lock a route is allowed to // have. MaxTotalTimelock uint32 // DefaultFinalCltvDelta is the default value used as final cltv delta // when an RPC caller doesn't specify a value. DefaultFinalCltvDelta uint16 // SubscribeHtlcEvents returns a subscription client for the node's // htlc events. SubscribeHtlcEvents func() (*subscribe.Client, error) // InterceptableForwarder exposes the ability to intercept forward events // by letting the router register a ForwardInterceptor. InterceptableForwarder htlcswitch.InterceptableHtlcForwarder // SetChannelEnabled exposes the ability to manually enable a channel. SetChannelEnabled func(wire.OutPoint) error // SetChannelDisabled exposes the ability to manually disable a channel SetChannelDisabled func(wire.OutPoint) error // SetChannelAuto exposes the ability to restore automatic channel state // management after manually setting channel status. SetChannelAuto func(wire.OutPoint) error } // MissionControl defines the mission control dependencies of routerrpc. type MissionControl interface { // GetProbability is expected to return the success probability of a // payment from fromNode to toNode. GetProbability(fromNode, toNode route.Vertex, amt lnwire.MilliSatoshi) float64 // ResetHistory resets the history of MissionControl returning it to a // state as if no payment attempts have been made. ResetHistory() error // GetHistorySnapshot takes a snapshot from the current mission control // state and actual probability estimates. GetHistorySnapshot() *routing.MissionControlSnapshot // ImportHistory imports the mission control snapshot to our internal // state. This import will only be applied in-memory, and will not be // persisted across restarts. ImportHistory(*routing.MissionControlSnapshot) error // GetPairHistorySnapshot returns the stored history for a given node // pair. GetPairHistorySnapshot(fromNode, toNode route.Vertex) routing.TimedPairResult // GetConfig gets mission control's current config. GetConfig() *routing.MissionControlConfig // SetConfig sets mission control's config to the values provided, if // they are valid. SetConfig(cfg *routing.MissionControlConfig) error } // QueryRoutes attempts to query the daemons' Channel Router for a possible // route to a target destination capable of carrying a specific amount of // satoshis within the route's flow. The retuned route contains the full // details required to craft and send an HTLC, also including the necessary // information that should be present within the Sphinx packet encapsulated // within the HTLC. // // TODO(roasbeef): should return a slice of routes in reality * create separate // PR to send based on well formatted route func (r *RouterBackend) QueryRoutes(ctx context.Context, in *lnrpc.QueryRoutesRequest) (*lnrpc.QueryRoutesResponse, error) { parsePubKey := func(key string) (route.Vertex, error) { pubKeyBytes, err := hex.DecodeString(key) if err != nil { return route.Vertex{}, err } return route.NewVertexFromBytes(pubKeyBytes) } // Parse the hex-encoded source and target public keys into full public // key objects we can properly manipulate. targetPubKey, err := parsePubKey(in.PubKey) if err != nil { return nil, err } var sourcePubKey route.Vertex if in.SourcePubKey != "" { var err error sourcePubKey, err = parsePubKey(in.SourcePubKey) if err != nil { return nil, err } } else { // If no source is specified, use self. sourcePubKey = r.SelfNode } // Currently, within the bootstrap phase of the network, we limit the // largest payment size allotted to (2^32) - 1 mSAT or 4.29 million // satoshis. amt, err := lnrpc.UnmarshallAmt(in.Amt, in.AmtMsat) if err != nil { return nil, err } // Unmarshall restrictions from request. feeLimit := lnrpc.CalculateFeeLimit(in.FeeLimit, amt) ignoredNodes := make(map[route.Vertex]struct{}) for _, ignorePubKey := range in.IgnoredNodes { ignoreVertex, err := route.NewVertexFromBytes(ignorePubKey) if err != nil { return nil, err } ignoredNodes[ignoreVertex] = struct{}{} } ignoredPairs := make(map[routing.DirectedNodePair]struct{}) // Convert deprecated ignoredEdges to pairs. for _, ignoredEdge := range in.IgnoredEdges { pair, err := r.rpcEdgeToPair(ignoredEdge) if err != nil { log.Warnf("Ignore channel %v skipped: %v", ignoredEdge.ChannelId, err) continue } ignoredPairs[pair] = struct{}{} } // Add ignored pairs to set. for _, ignorePair := range in.IgnoredPairs { from, err := route.NewVertexFromBytes(ignorePair.From) if err != nil { return nil, err } to, err := route.NewVertexFromBytes(ignorePair.To) if err != nil { return nil, err } pair := routing.NewDirectedNodePair(from, to) ignoredPairs[pair] = struct{}{} } // Since QueryRoutes allows having a different source other than // ourselves, we'll only apply our max time lock if we are the source. maxTotalTimelock := r.MaxTotalTimelock if sourcePubKey != r.SelfNode { maxTotalTimelock = math.MaxUint32 } cltvLimit, err := ValidateCLTVLimit(in.CltvLimit, maxTotalTimelock) if err != nil { return nil, err } // We need to subtract the final delta before passing it into path // finding. The optimal path is independent of the final cltv delta and // the path finding algorithm is unaware of this value. finalCLTVDelta := r.DefaultFinalCltvDelta if in.FinalCltvDelta != 0 { finalCLTVDelta = uint16(in.FinalCltvDelta) } cltvLimit -= uint32(finalCLTVDelta) // Parse destination feature bits. features, err := UnmarshalFeatures(in.DestFeatures) if err != nil { return nil, err } restrictions := &routing.RestrictParams{ FeeLimit: feeLimit, ProbabilitySource: func(fromNode, toNode route.Vertex, amt lnwire.MilliSatoshi) float64 { if _, ok := ignoredNodes[fromNode]; ok { return 0 } pair := routing.DirectedNodePair{ From: fromNode, To: toNode, } if _, ok := ignoredPairs[pair]; ok { return 0 } if !in.UseMissionControl { return 1 } return r.MissionControl.GetProbability( fromNode, toNode, amt, ) }, DestCustomRecords: record.CustomSet(in.DestCustomRecords), CltvLimit: cltvLimit, DestFeatures: features, } // Pass along an outgoing channel restriction if specified. if in.OutgoingChanId != 0 { restrictions.OutgoingChannelIDs = []uint64{in.OutgoingChanId} } // Pass along a last hop restriction if specified. if len(in.LastHopPubkey) > 0 { lastHop, err := route.NewVertexFromBytes( in.LastHopPubkey, ) if err != nil { return nil, err } restrictions.LastHop = &lastHop } // If we have any TLV records destined for the final hop, then we'll // attempt to decode them now into a form that the router can more // easily manipulate. customRecords := record.CustomSet(in.DestCustomRecords) if err := customRecords.Validate(); err != nil { return nil, err } // Convert route hints to an edge map. routeHints, err := unmarshallRouteHints(in.RouteHints) if err != nil { return nil, err } routeHintEdges, err := routing.RouteHintsToEdges( routeHints, targetPubKey, ) if err != nil { return nil, err } // Query the channel router for a possible path to the destination that // can carry `in.Amt` satoshis _including_ the total fee required on // the route. route, err := r.FindRoute( sourcePubKey, targetPubKey, amt, restrictions, customRecords, routeHintEdges, finalCLTVDelta, ) if err != nil { return nil, err } // For each valid route, we'll convert the result into the format // required by the RPC system. rpcRoute, err := r.MarshallRoute(route) if err != nil { return nil, err } // Calculate route success probability. Do not rely on a probability // that could have been returned from path finding, because mission // control may have been disabled in the provided ProbabilitySource. successProb := r.getSuccessProbability(route) routeResp := &lnrpc.QueryRoutesResponse{ Routes: []*lnrpc.Route{rpcRoute}, SuccessProb: successProb, } return routeResp, nil } // getSuccessProbability returns the success probability for the given route // based on the current state of mission control. func (r *RouterBackend) getSuccessProbability(rt *route.Route) float64 { fromNode := rt.SourcePubKey amtToFwd := rt.TotalAmount successProb := 1.0 for _, hop := range rt.Hops { toNode := hop.PubKeyBytes probability := r.MissionControl.GetProbability( fromNode, toNode, amtToFwd, ) successProb *= probability amtToFwd = hop.AmtToForward fromNode = toNode } return successProb } // rpcEdgeToPair looks up the provided channel and returns the channel endpoints // as a directed pair. func (r *RouterBackend) rpcEdgeToPair(e *lnrpc.EdgeLocator) ( routing.DirectedNodePair, error) { a, b, err := r.FetchChannelEndpoints(e.ChannelId) if err != nil { return routing.DirectedNodePair{}, err } var pair routing.DirectedNodePair if e.DirectionReverse { pair.From, pair.To = b, a } else { pair.From, pair.To = a, b } return pair, nil } // MarshallRoute marshalls an internal route to an rpc route struct. func (r *RouterBackend) MarshallRoute(route *route.Route) (*lnrpc.Route, error) { resp := &lnrpc.Route{ TotalTimeLock: route.TotalTimeLock, TotalFees: int64(route.TotalFees().ToSatoshis()), TotalFeesMsat: int64(route.TotalFees()), TotalAmt: int64(route.TotalAmount.ToSatoshis()), TotalAmtMsat: int64(route.TotalAmount), Hops: make([]*lnrpc.Hop, len(route.Hops)), } incomingAmt := route.TotalAmount for i, hop := range route.Hops { fee := route.HopFee(i) // Channel capacity is not a defining property of a route. For // backwards RPC compatibility, we retrieve it here from the // graph. chanCapacity, err := r.FetchChannelCapacity(hop.ChannelID) if err != nil { // If capacity cannot be retrieved, this may be a // not-yet-received or private channel. Then report // amount that is sent through the channel as capacity. chanCapacity = incomingAmt.ToSatoshis() } // Extract the MPP fields if present on this hop. var mpp *lnrpc.MPPRecord if hop.MPP != nil { addr := hop.MPP.PaymentAddr() mpp = &lnrpc.MPPRecord{ PaymentAddr: addr[:], TotalAmtMsat: int64(hop.MPP.TotalMsat()), } } resp.Hops[i] = &lnrpc.Hop{ ChanId: hop.ChannelID, ChanCapacity: int64(chanCapacity), AmtToForward: int64(hop.AmtToForward.ToSatoshis()), AmtToForwardMsat: int64(hop.AmtToForward), Fee: int64(fee.ToSatoshis()), FeeMsat: int64(fee), Expiry: uint32(hop.OutgoingTimeLock), PubKey: hex.EncodeToString( hop.PubKeyBytes[:], ), CustomRecords: hop.CustomRecords, TlvPayload: !hop.LegacyPayload, MppRecord: mpp, } incomingAmt = hop.AmtToForward } return resp, nil } // UnmarshallHopWithPubkey unmarshalls an rpc hop for which the pubkey has // already been extracted. func UnmarshallHopWithPubkey(rpcHop *lnrpc.Hop, pubkey route.Vertex) (*route.Hop, error) { customRecords := record.CustomSet(rpcHop.CustomRecords) if err := customRecords.Validate(); err != nil { return nil, err } mpp, err := UnmarshalMPP(rpcHop.MppRecord) if err != nil { return nil, err } amp, err := UnmarshalAMP(rpcHop.AmpRecord) if err != nil { return nil, err } return &route.Hop{ OutgoingTimeLock: rpcHop.Expiry, AmtToForward: lnwire.MilliSatoshi(rpcHop.AmtToForwardMsat), PubKeyBytes: pubkey, ChannelID: rpcHop.ChanId, CustomRecords: customRecords, LegacyPayload: !rpcHop.TlvPayload, MPP: mpp, AMP: amp, }, nil } // UnmarshallHop unmarshalls an rpc hop that may or may not contain a node // pubkey. func (r *RouterBackend) UnmarshallHop(rpcHop *lnrpc.Hop, prevNodePubKey [33]byte) (*route.Hop, error) { var pubKeyBytes [33]byte if rpcHop.PubKey != "" { // Unmarshall the provided hop pubkey. pubKey, err := hex.DecodeString(rpcHop.PubKey) if err != nil { return nil, fmt.Errorf("cannot decode pubkey %s", rpcHop.PubKey) } copy(pubKeyBytes[:], pubKey) } else { // If no pub key is given of the hop, the local channel graph // needs to be queried to complete the information necessary for // routing. Discard edge policies, because they may be nil. node1, node2, err := r.FetchChannelEndpoints(rpcHop.ChanId) if err != nil { return nil, err } switch { case prevNodePubKey == node1: pubKeyBytes = node2 case prevNodePubKey == node2: pubKeyBytes = node1 default: return nil, fmt.Errorf("channel edge does not match " + "expected node") } } return UnmarshallHopWithPubkey(rpcHop, pubKeyBytes) } // UnmarshallRoute unmarshalls an rpc route. For hops that don't specify a // pubkey, the channel graph is queried. func (r *RouterBackend) UnmarshallRoute(rpcroute *lnrpc.Route) ( *route.Route, error) { prevNodePubKey := r.SelfNode hops := make([]*route.Hop, len(rpcroute.Hops)) for i, hop := range rpcroute.Hops { routeHop, err := r.UnmarshallHop(hop, prevNodePubKey) if err != nil { return nil, err } hops[i] = routeHop prevNodePubKey = routeHop.PubKeyBytes } route, err := route.NewRouteFromHops( lnwire.MilliSatoshi(rpcroute.TotalAmtMsat), rpcroute.TotalTimeLock, r.SelfNode, hops, ) if err != nil { return nil, err } return route, nil } // extractIntentFromSendRequest attempts to parse the SendRequest details // required to dispatch a client from the information presented by an RPC // client. func (r *RouterBackend) extractIntentFromSendRequest( rpcPayReq *SendPaymentRequest) (*routing.LightningPayment, error) { payIntent := &routing.LightningPayment{} // Pass along restrictions on the outgoing channels that may be used. payIntent.OutgoingChannelIDs = rpcPayReq.OutgoingChanIds // Add the deprecated single outgoing channel restriction if present. if rpcPayReq.OutgoingChanId != 0 { if payIntent.OutgoingChannelIDs != nil { return nil, errors.New("outgoing_chan_id and " + "outgoing_chan_ids are mutually exclusive") } payIntent.OutgoingChannelIDs = append( payIntent.OutgoingChannelIDs, rpcPayReq.OutgoingChanId, ) } // Pass along a last hop restriction if specified. if len(rpcPayReq.LastHopPubkey) > 0 { lastHop, err := route.NewVertexFromBytes( rpcPayReq.LastHopPubkey, ) if err != nil { return nil, err } payIntent.LastHop = &lastHop } // Take the CLTV limit from the request if set, otherwise use the max. cltvLimit, err := ValidateCLTVLimit( uint32(rpcPayReq.CltvLimit), r.MaxTotalTimelock, ) if err != nil { return nil, err } payIntent.CltvLimit = cltvLimit // Attempt to parse the max parts value set by the user, if this value // isn't set, then we'll use the current default value for this // setting. maxParts := rpcPayReq.MaxParts if maxParts == 0 { maxParts = DefaultMaxParts } payIntent.MaxParts = maxParts // If this payment had a max shard amount specified, then we'll apply // that now, which'll force us to always make payment splits smaller // than this. if rpcPayReq.MaxShardSizeMsat > 0 { shardAmtMsat := lnwire.MilliSatoshi(rpcPayReq.MaxShardSizeMsat) payIntent.MaxShardAmt = &shardAmtMsat } // Take fee limit from request. payIntent.FeeLimit, err = lnrpc.UnmarshallAmt( rpcPayReq.FeeLimitSat, rpcPayReq.FeeLimitMsat, ) if err != nil { return nil, err } // Set payment attempt timeout. if rpcPayReq.TimeoutSeconds == 0 { return nil, errors.New("timeout_seconds must be specified") } customRecords := record.CustomSet(rpcPayReq.DestCustomRecords) if err := customRecords.Validate(); err != nil { return nil, err } payIntent.DestCustomRecords = customRecords payIntent.PayAttemptTimeout = time.Second * time.Duration(rpcPayReq.TimeoutSeconds) // Route hints. routeHints, err := unmarshallRouteHints( rpcPayReq.RouteHints, ) if err != nil { return nil, err } payIntent.RouteHints = routeHints // Unmarshall either sat or msat amount from request. reqAmt, err := lnrpc.UnmarshallAmt( rpcPayReq.Amt, rpcPayReq.AmtMsat, ) if err != nil { return nil, err } // If the payment request field isn't blank, then the details of the // invoice are encoded entirely within the encoded payReq. So we'll // attempt to decode it, populating the payment accordingly. if rpcPayReq.PaymentRequest != "" { switch { case len(rpcPayReq.Dest) > 0: return nil, errors.New("dest and payment_request " + "cannot appear together") case len(rpcPayReq.PaymentHash) > 0: return nil, errors.New("dest and payment_hash " + "cannot appear together") case rpcPayReq.FinalCltvDelta != 0: return nil, errors.New("dest and final_cltv_delta " + "cannot appear together") } payReq, err := zpay32.Decode( rpcPayReq.PaymentRequest, r.ActiveNetParams, ) if err != nil { return nil, err } // Next, we'll ensure that this payreq hasn't already expired. err = ValidatePayReqExpiry(payReq) if err != nil { return nil, err } // If the amount was not included in the invoice, then we let // the payee specify the amount of satoshis they wish to send. // We override the amount to pay with the amount provided from // the payment request. if payReq.MilliSat == nil { if reqAmt == 0 { return nil, errors.New("amount must be " + "specified when paying a zero amount " + "invoice") } payIntent.Amount = reqAmt } else { if reqAmt != 0 { return nil, errors.New("amount must not be " + "specified when paying a non-zero " + " amount invoice") } payIntent.Amount = *payReq.MilliSat } if !payReq.Features.HasFeature(lnwire.MPPOptional) { payIntent.MaxParts = 1 } err = payIntent.SetPaymentHash(*payReq.PaymentHash) if err != nil { return nil, err } destKey := payReq.Destination.SerializeCompressed() copy(payIntent.Target[:], destKey) payIntent.FinalCLTVDelta = uint16(payReq.MinFinalCLTVExpiry()) payIntent.RouteHints = append( payIntent.RouteHints, payReq.RouteHints..., ) payIntent.DestFeatures = payReq.Features payIntent.PaymentAddr = payReq.PaymentAddr payIntent.PaymentRequest = []byte(rpcPayReq.PaymentRequest) } else { // Otherwise, If the payment request field was not specified // (and a custom route wasn't specified), construct the payment // from the other fields. // Payment destination. target, err := route.NewVertexFromBytes(rpcPayReq.Dest) if err != nil { return nil, err } payIntent.Target = target // Final payment CLTV delta. if rpcPayReq.FinalCltvDelta != 0 { payIntent.FinalCLTVDelta = uint16(rpcPayReq.FinalCltvDelta) } else { payIntent.FinalCLTVDelta = r.DefaultFinalCltvDelta } // Amount. if reqAmt == 0 { return nil, errors.New("amount must be specified") } payIntent.Amount = reqAmt // Parse destination feature bits. features, err := UnmarshalFeatures(rpcPayReq.DestFeatures) if err != nil { return nil, err } // Validate the features if any was specified. if features != nil { err = feature.ValidateDeps(features) if err != nil { return nil, err } } // If this is an AMP payment, we must generate the initial // randomness. if rpcPayReq.Amp { // If no destination features were specified, we set // those necessary for AMP payments. if features == nil { ampFeatures := []lnrpc.FeatureBit{ lnrpc.FeatureBit_TLV_ONION_OPT, lnrpc.FeatureBit_PAYMENT_ADDR_OPT, lnrpc.FeatureBit_MPP_OPT, lnrpc.FeatureBit_AMP_OPT, } features, err = UnmarshalFeatures(ampFeatures) if err != nil { return nil, err } } // First make sure the destination supports AMP. if !features.HasFeature(lnwire.AMPOptional) { return nil, fmt.Errorf("destination doesn't " + "support AMP payments") } // If no payment address is set, generate a random one. var payAddr [32]byte if len(rpcPayReq.PaymentAddr) == 0 { _, err = rand.Read(payAddr[:]) if err != nil { return nil, err } } else { copy(payAddr[:], rpcPayReq.PaymentAddr) } payIntent.PaymentAddr = &payAddr // Generate random SetID and root share. var setID [32]byte _, err = rand.Read(setID[:]) if err != nil { return nil, err } var rootShare [32]byte _, err = rand.Read(rootShare[:]) if err != nil { return nil, err } err := payIntent.SetAMP(&routing.AMPOptions{ SetID: setID, RootShare: rootShare, }) if err != nil { return nil, err } } else { // Payment hash. paymentHash, err := lntypes.MakeHash(rpcPayReq.PaymentHash) if err != nil { return nil, err } err = payIntent.SetPaymentHash(paymentHash) if err != nil { return nil, err } // If the payment addresses is specified, then we'll // also populate that now as well. if len(rpcPayReq.PaymentAddr) != 0 { var payAddr [32]byte copy(payAddr[:], rpcPayReq.PaymentAddr) payIntent.PaymentAddr = &payAddr } } payIntent.DestFeatures = features } // Check for disallowed payments to self. if !rpcPayReq.AllowSelfPayment && payIntent.Target == r.SelfNode { return nil, errors.New("self-payments not allowed") } return payIntent, nil } // unmarshallRouteHints unmarshalls a list of route hints. func unmarshallRouteHints(rpcRouteHints []*lnrpc.RouteHint) ( [][]zpay32.HopHint, error) { routeHints := make([][]zpay32.HopHint, 0, len(rpcRouteHints)) for _, rpcRouteHint := range rpcRouteHints { routeHint := make( []zpay32.HopHint, 0, len(rpcRouteHint.HopHints), ) for _, rpcHint := range rpcRouteHint.HopHints { hint, err := unmarshallHopHint(rpcHint) if err != nil { return nil, err } routeHint = append(routeHint, hint) } routeHints = append(routeHints, routeHint) } return routeHints, nil } // unmarshallHopHint unmarshalls a single hop hint. func unmarshallHopHint(rpcHint *lnrpc.HopHint) (zpay32.HopHint, error) { pubBytes, err := hex.DecodeString(rpcHint.NodeId) if err != nil { return zpay32.HopHint{}, err } pubkey, err := btcec.ParsePubKey(pubBytes, btcec.S256()) if err != nil { return zpay32.HopHint{}, err } return zpay32.HopHint{ NodeID: pubkey, ChannelID: rpcHint.ChanId, FeeBaseMSat: rpcHint.FeeBaseMsat, FeeProportionalMillionths: rpcHint.FeeProportionalMillionths, CLTVExpiryDelta: uint16(rpcHint.CltvExpiryDelta), }, nil } // UnmarshalFeatures converts a list of uint32's into a valid feature vector. // This method checks that feature bit pairs aren't assigned toegether, and // validates transitive dependencies. func UnmarshalFeatures( rpcFeatures []lnrpc.FeatureBit) (*lnwire.FeatureVector, error) { // If no destination features are specified we'll return nil to signal // that the router should try to use the graph as a fallback. if rpcFeatures == nil { return nil, nil } raw := lnwire.NewRawFeatureVector() for _, bit := range rpcFeatures { err := raw.SafeSet(lnwire.FeatureBit(bit)) if err != nil { return nil, err } } return lnwire.NewFeatureVector(raw, lnwire.Features), nil } // ValidatePayReqExpiry checks if the passed payment request has expired. In // the case it has expired, an error will be returned. func ValidatePayReqExpiry(payReq *zpay32.Invoice) error { expiry := payReq.Expiry() validUntil := payReq.Timestamp.Add(expiry) if time.Now().After(validUntil) { return fmt.Errorf("invoice expired. Valid until %v", validUntil) } return nil } // ValidateCLTVLimit returns a valid CLTV limit given a value and a maximum. If // the value exceeds the maximum, then an error is returned. If the value is 0, // then the maximum is used. func ValidateCLTVLimit(val, max uint32) (uint32, error) { switch { case val == 0: return max, nil case val > max: return 0, fmt.Errorf("total time lock of %v exceeds max "+ "allowed %v", val, max) default: return val, nil } } // UnmarshalMPP accepts the mpp_total_amt_msat and mpp_payment_addr fields from // an RPC request and converts into an record.MPP object. An error is returned // if the payment address is not 0 or 32 bytes. If the total amount and payment // address are zero-value, the return value will be nil signaling there is no // MPP record to attach to this hop. Otherwise, a non-nil reocrd will be // contained combining the provided values. func UnmarshalMPP(reqMPP *lnrpc.MPPRecord) (*record.MPP, error) { // If no MPP record was submitted, assume the user wants to send a // regular payment. if reqMPP == nil { return nil, nil } reqTotal := reqMPP.TotalAmtMsat reqAddr := reqMPP.PaymentAddr switch { // No MPP fields were provided. case reqTotal == 0 && len(reqAddr) == 0: return nil, fmt.Errorf("missing total_msat and payment_addr") // Total is present, but payment address is missing. case reqTotal > 0 && len(reqAddr) == 0: return nil, fmt.Errorf("missing payment_addr") // Payment address is present, but total is missing. case reqTotal == 0 && len(reqAddr) > 0: return nil, fmt.Errorf("missing total_msat") } addr, err := lntypes.MakeHash(reqAddr) if err != nil { return nil, fmt.Errorf("unable to parse "+ "payment_addr: %v", err) } total := lnwire.MilliSatoshi(reqTotal) return record.NewMPP(total, addr), nil } func UnmarshalAMP(reqAMP *lnrpc.AMPRecord) (*record.AMP, error) { if reqAMP == nil { return nil, nil } reqRootShare := reqAMP.RootShare reqSetID := reqAMP.SetId switch { case len(reqRootShare) != 32: return nil, errors.New("AMP root_share must be 32 bytes") case len(reqSetID) != 32: return nil, errors.New("AMP set_id must be 32 bytes") } var ( rootShare [32]byte setID [32]byte ) copy(rootShare[:], reqRootShare) copy(setID[:], reqSetID) return record.NewAMP(rootShare, setID, reqAMP.ChildIndex), nil } // MarshalHTLCAttempt constructs an RPC HTLCAttempt from the db representation. func (r *RouterBackend) MarshalHTLCAttempt( htlc channeldb.HTLCAttempt) (*lnrpc.HTLCAttempt, error) { route, err := r.MarshallRoute(&htlc.Route) if err != nil { return nil, err } rpcAttempt := &lnrpc.HTLCAttempt{ AttemptId: htlc.AttemptID, AttemptTimeNs: MarshalTimeNano(htlc.AttemptTime), Route: route, } switch { case htlc.Settle != nil: rpcAttempt.Status = lnrpc.HTLCAttempt_SUCCEEDED rpcAttempt.ResolveTimeNs = MarshalTimeNano( htlc.Settle.SettleTime, ) rpcAttempt.Preimage = htlc.Settle.Preimage[:] case htlc.Failure != nil: rpcAttempt.Status = lnrpc.HTLCAttempt_FAILED rpcAttempt.ResolveTimeNs = MarshalTimeNano( htlc.Failure.FailTime, ) var err error rpcAttempt.Failure, err = marshallHtlcFailure(htlc.Failure) if err != nil { return nil, err } default: rpcAttempt.Status = lnrpc.HTLCAttempt_IN_FLIGHT } return rpcAttempt, nil } // marshallHtlcFailure marshalls htlc fail info from the database to its rpc // representation. func marshallHtlcFailure(failure *channeldb.HTLCFailInfo) (*lnrpc.Failure, error) { rpcFailure := &lnrpc.Failure{ FailureSourceIndex: failure.FailureSourceIndex, } switch failure.Reason { case channeldb.HTLCFailUnknown: rpcFailure.Code = lnrpc.Failure_UNKNOWN_FAILURE case channeldb.HTLCFailUnreadable: rpcFailure.Code = lnrpc.Failure_UNREADABLE_FAILURE case channeldb.HTLCFailInternal: rpcFailure.Code = lnrpc.Failure_INTERNAL_FAILURE case channeldb.HTLCFailMessage: err := marshallWireError(failure.Message, rpcFailure) if err != nil { return nil, err } default: return nil, errors.New("unknown htlc failure reason") } return rpcFailure, nil } // MarshalTimeNano converts a time.Time into its nanosecond representation. If // the time is zero, this method simply returns 0, since calling UnixNano() on a // zero-valued time is undefined. func MarshalTimeNano(t time.Time) int64 { if t.IsZero() { return 0 } return t.UnixNano() } // marshallError marshall an error as received from the switch to rpc structs // suitable for returning to the caller of an rpc method. // // Because of difficulties with using protobuf oneof constructs in some // languages, the decision was made here to use a single message format for all // failure messages with some fields left empty depending on the failure type. func marshallError(sendError error) (*lnrpc.Failure, error) { response := &lnrpc.Failure{} if sendError == htlcswitch.ErrUnreadableFailureMessage { response.Code = lnrpc.Failure_UNREADABLE_FAILURE return response, nil } rtErr, ok := sendError.(htlcswitch.ClearTextError) if !ok { return nil, sendError } err := marshallWireError(rtErr.WireMessage(), response) if err != nil { return nil, err } // If the ClearTextError received is a ForwardingError, the error // originated from a node along the route, not locally on our outgoing // link. We set failureSourceIdx to the index of the node where the // failure occurred. If the error is not a ForwardingError, the failure // occurred at our node, so we leave the index as 0 to indicate that // we failed locally. fErr, ok := rtErr.(*htlcswitch.ForwardingError) if ok { response.FailureSourceIndex = uint32(fErr.FailureSourceIdx) } return response, nil } // marshallError marshall an error as received from the switch to rpc structs // suitable for returning to the caller of an rpc method. // // Because of difficulties with using protobuf oneof constructs in some // languages, the decision was made here to use a single message format for all // failure messages with some fields left empty depending on the failure type. func marshallWireError(msg lnwire.FailureMessage, response *lnrpc.Failure) error { switch onionErr := msg.(type) { case *lnwire.FailIncorrectDetails: response.Code = lnrpc.Failure_INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS response.Height = onionErr.Height() case *lnwire.FailIncorrectPaymentAmount: response.Code = lnrpc.Failure_INCORRECT_PAYMENT_AMOUNT case *lnwire.FailFinalIncorrectCltvExpiry: response.Code = lnrpc.Failure_FINAL_INCORRECT_CLTV_EXPIRY response.CltvExpiry = onionErr.CltvExpiry case *lnwire.FailFinalIncorrectHtlcAmount: response.Code = lnrpc.Failure_FINAL_INCORRECT_HTLC_AMOUNT response.HtlcMsat = uint64(onionErr.IncomingHTLCAmount) case *lnwire.FailFinalExpiryTooSoon: response.Code = lnrpc.Failure_FINAL_EXPIRY_TOO_SOON case *lnwire.FailInvalidRealm: response.Code = lnrpc.Failure_INVALID_REALM case *lnwire.FailExpiryTooSoon: response.Code = lnrpc.Failure_EXPIRY_TOO_SOON response.ChannelUpdate = marshallChannelUpdate(&onionErr.Update) case *lnwire.FailExpiryTooFar: response.Code = lnrpc.Failure_EXPIRY_TOO_FAR case *lnwire.FailInvalidOnionVersion: response.Code = lnrpc.Failure_INVALID_ONION_VERSION response.OnionSha_256 = onionErr.OnionSHA256[:] case *lnwire.FailInvalidOnionHmac: response.Code = lnrpc.Failure_INVALID_ONION_HMAC response.OnionSha_256 = onionErr.OnionSHA256[:] case *lnwire.FailInvalidOnionKey: response.Code = lnrpc.Failure_INVALID_ONION_KEY response.OnionSha_256 = onionErr.OnionSHA256[:] case *lnwire.FailAmountBelowMinimum: response.Code = lnrpc.Failure_AMOUNT_BELOW_MINIMUM response.ChannelUpdate = marshallChannelUpdate(&onionErr.Update) response.HtlcMsat = uint64(onionErr.HtlcMsat) case *lnwire.FailFeeInsufficient: response.Code = lnrpc.Failure_FEE_INSUFFICIENT response.ChannelUpdate = marshallChannelUpdate(&onionErr.Update) response.HtlcMsat = uint64(onionErr.HtlcMsat) case *lnwire.FailIncorrectCltvExpiry: response.Code = lnrpc.Failure_INCORRECT_CLTV_EXPIRY response.ChannelUpdate = marshallChannelUpdate(&onionErr.Update) response.CltvExpiry = onionErr.CltvExpiry case *lnwire.FailChannelDisabled: response.Code = lnrpc.Failure_CHANNEL_DISABLED response.ChannelUpdate = marshallChannelUpdate(&onionErr.Update) response.Flags = uint32(onionErr.Flags) case *lnwire.FailTemporaryChannelFailure: response.Code = lnrpc.Failure_TEMPORARY_CHANNEL_FAILURE response.ChannelUpdate = marshallChannelUpdate(onionErr.Update) case *lnwire.FailRequiredNodeFeatureMissing: response.Code = lnrpc.Failure_REQUIRED_NODE_FEATURE_MISSING case *lnwire.FailRequiredChannelFeatureMissing: response.Code = lnrpc.Failure_REQUIRED_CHANNEL_FEATURE_MISSING case *lnwire.FailUnknownNextPeer: response.Code = lnrpc.Failure_UNKNOWN_NEXT_PEER case *lnwire.FailTemporaryNodeFailure: response.Code = lnrpc.Failure_TEMPORARY_NODE_FAILURE case *lnwire.FailPermanentNodeFailure: response.Code = lnrpc.Failure_PERMANENT_NODE_FAILURE case *lnwire.FailPermanentChannelFailure: response.Code = lnrpc.Failure_PERMANENT_CHANNEL_FAILURE case *lnwire.FailMPPTimeout: response.Code = lnrpc.Failure_MPP_TIMEOUT case *lnwire.InvalidOnionPayload: response.Code = lnrpc.Failure_INVALID_ONION_PAYLOAD case nil: response.Code = lnrpc.Failure_UNKNOWN_FAILURE default: return fmt.Errorf("cannot marshall failure %T", onionErr) } return nil } // marshallChannelUpdate marshalls a channel update as received over the wire to // the router rpc format. func marshallChannelUpdate(update *lnwire.ChannelUpdate) *lnrpc.ChannelUpdate { if update == nil { return nil } return &lnrpc.ChannelUpdate{ Signature: update.Signature[:], ChainHash: update.ChainHash[:], ChanId: update.ShortChannelID.ToUint64(), Timestamp: update.Timestamp, MessageFlags: uint32(update.MessageFlags), ChannelFlags: uint32(update.ChannelFlags), TimeLockDelta: uint32(update.TimeLockDelta), HtlcMinimumMsat: uint64(update.HtlcMinimumMsat), BaseFee: update.BaseFee, FeeRate: update.FeeRate, HtlcMaximumMsat: uint64(update.HtlcMaximumMsat), ExtraOpaqueData: update.ExtraOpaqueData, } } // MarshallPayment marshall a payment to its rpc representation. func (r *RouterBackend) MarshallPayment(payment *channeldb.MPPayment) ( *lnrpc.Payment, error) { // Fetch the payment's preimage and the total paid in fees. var ( fee lnwire.MilliSatoshi preimage lntypes.Preimage ) for _, htlc := range payment.HTLCs { // If any of the htlcs have settled, extract a valid // preimage. if htlc.Settle != nil { preimage = htlc.Settle.Preimage fee += htlc.Route.TotalFees() } } msatValue := int64(payment.Info.Value) satValue := int64(payment.Info.Value.ToSatoshis()) status, err := convertPaymentStatus(payment.Status) if err != nil { return nil, err } htlcs := make([]*lnrpc.HTLCAttempt, 0, len(payment.HTLCs)) for _, dbHTLC := range payment.HTLCs { htlc, err := r.MarshalHTLCAttempt(dbHTLC) if err != nil { return nil, err } htlcs = append(htlcs, htlc) } paymentID := payment.Info.PaymentIdentifier creationTimeNS := MarshalTimeNano(payment.Info.CreationTime) failureReason, err := marshallPaymentFailureReason( payment.FailureReason, ) if err != nil { return nil, err } return &lnrpc.Payment{ // TODO: set this to setID for AMP-payments? PaymentHash: hex.EncodeToString(paymentID[:]), Value: satValue, ValueMsat: msatValue, ValueSat: satValue, CreationDate: payment.Info.CreationTime.Unix(), CreationTimeNs: creationTimeNS, Fee: int64(fee.ToSatoshis()), FeeSat: int64(fee.ToSatoshis()), FeeMsat: int64(fee), PaymentPreimage: hex.EncodeToString(preimage[:]), PaymentRequest: string(payment.Info.PaymentRequest), Status: status, Htlcs: htlcs, PaymentIndex: payment.SequenceNum, FailureReason: failureReason, }, nil } // convertPaymentStatus converts a channeldb.PaymentStatus to the type expected // by the RPC. func convertPaymentStatus(dbStatus channeldb.PaymentStatus) ( lnrpc.Payment_PaymentStatus, error) { switch dbStatus { case channeldb.StatusUnknown: return lnrpc.Payment_UNKNOWN, nil case channeldb.StatusInFlight: return lnrpc.Payment_IN_FLIGHT, nil case channeldb.StatusSucceeded: return lnrpc.Payment_SUCCEEDED, nil case channeldb.StatusFailed: return lnrpc.Payment_FAILED, nil default: return 0, fmt.Errorf("unhandled payment status %v", dbStatus) } } // marshallPaymentFailureReason marshalls the failure reason to the corresponding rpc // type. func marshallPaymentFailureReason(reason *channeldb.FailureReason) ( lnrpc.PaymentFailureReason, error) { if reason == nil { return lnrpc.PaymentFailureReason_FAILURE_REASON_NONE, nil } switch *reason { case channeldb.FailureReasonTimeout: return lnrpc.PaymentFailureReason_FAILURE_REASON_TIMEOUT, nil case channeldb.FailureReasonNoRoute: return lnrpc.PaymentFailureReason_FAILURE_REASON_NO_ROUTE, nil case channeldb.FailureReasonError: return lnrpc.PaymentFailureReason_FAILURE_REASON_ERROR, nil case channeldb.FailureReasonPaymentDetails: return lnrpc.PaymentFailureReason_FAILURE_REASON_INCORRECT_PAYMENT_DETAILS, nil case channeldb.FailureReasonInsufficientBalance: return lnrpc.PaymentFailureReason_FAILURE_REASON_INSUFFICIENT_BALANCE, nil } return 0, errors.New("unknown failure reason") }