SendToRoute

danger

This RPC is deprecated and will be removed in a future version.

Deprecated, use routerrpc.SendToRouteV2. SendToRoute is a bi-directional streaming RPC for sending payment through the Lightning Network. This method differs from SendPayment in that it allows users to specify a full route manually. This can be used for things like rebalancing, and atomic swaps.

Source: lightning.proto

gRPC

info

This is a bidirectional-streaming RPC

rpc SendToRoute (stream SendToRouteRequest) returns (stream SendResponse);

Code Samples

gRPC

Javascript

const fs = require('fs');
const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');

const GRPC_HOST = 'localhost:10009'
const MACAROON_PATH = 'LND_DIR/data/chain/bitcoin/regtest/admin.macaroon'
const TLS_PATH = 'LND_DIR/tls.cert'

const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true,
};
const packageDefinition = protoLoader.loadSync('lightning.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const tlsCert = fs.readFileSync(TLS_PATH);
const sslCreds = grpc.credentials.createSsl(tlsCert);
const macaroon = fs.readFileSync(MACAROON_PATH).toString('hex');
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let client = new lnrpc.Lightning(GRPC_HOST, creds);
let request = {
  payment_hash: <bytes>,
  payment_hash_string: <string>,
  route: <Route>,
};
let call = client.sendToRoute({});
call.on('data', function(response) {
  // A response was received from the server.
  console.log(response);
});
call.on('status', function(status) {
  // The current status of the stream.
});
call.on('end', function() {
  // The server has closed the stream.
});
call.write(request);
// Console output:
//  {
//    "payment_error": <string>,
//    "payment_preimage": <bytes>,
//    "payment_route": <Route>,
//    "payment_hash": <bytes>,
//  }

Python

import codecs, grpc, os
# Generate the following 2 modules by compiling the lightning.proto with the grpcio-tools.
# See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
import lightning_pb2 as lnrpc, lightning_pb2_grpc as lightningstub

GRPC_HOST = 'localhost:10009'
MACAROON_PATH = 'LND_DIR/data/chain/bitcoin/regtest/admin.macaroon'
TLS_PATH = 'LND_DIR/tls.cert'

# create macaroon credentials
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
def metadata_callback(context, callback):
  callback([('macaroon', macaroon)], None)
auth_creds = grpc.metadata_call_credentials(metadata_callback)
# create SSL credentials
os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
cert = open(TLS_PATH, 'rb').read()
ssl_creds = grpc.ssl_channel_credentials(cert)
# combine macaroon and SSL credentials
combined_creds = grpc.composite_channel_credentials(ssl_creds, auth_creds)
# make the request
channel = grpc.secure_channel(GRPC_HOST, combined_creds)
stub = lightningstub.LightningStub(channel)
# Define a generator that returns an Iterable of SendToRouteRequest objects.
def request_generator():
    # Initialization code here.
    while True:
        # Parameters here can be set as arguments to the generator.
        request = lnrpc.SendToRouteRequest(
            payment_hash=<bytes>,
            payment_hash_string=<string>,
            route=<Route>,
        )
        yield request
        # Do things between iterations here.
request_iterable = request_generator()
for response in stub.SendToRoute(request_iterable):
  print(response)
# {
#    "payment_error": <string>,
#    "payment_preimage": <bytes>,
#    "payment_route": <Route>,
#    "payment_hash": <bytes>,
# }

Shell

$ lncli sendtoroute --help

NAME:
   lncli sendtoroute - Send a payment over a predefined route.

USAGE:
   lncli sendtoroute [command options] [arguments...]

CATEGORY:
   Payments

DESCRIPTION:
   
  Send a payment over Lightning using a specific route. One must specify
  the route to attempt and the payment hash. This command can even
  be chained with the response to queryroutes or buildroute. This command
  can be used to implement channel rebalancing by crafting a self-route,
  or even atomic swaps using a self-route that crosses multiple chains.

  There are three ways to specify a route:
     * using the --routes parameter to manually specify a JSON encoded
       route in the format of the return value of queryroutes or
       buildroute:
           (lncli sendtoroute --payment_hash=<pay_hash> --routes=<route>)

     * passing the route as a positional argument:
           (lncli sendtoroute --payment_hash=pay_hash <route>)

     * or reading in the route from stdin, which can allow chaining the
       response from queryroutes or buildroute, or even read in a file
       with a pre-computed route:
           (lncli queryroutes --args.. | lncli sendtoroute --payment_hash= -

       notice the '-' at the end, which signals that lncli should read
       the route in from stdin
  

OPTIONS:
   --payment_hash value, --pay_hash value  the hash to use within the payment's HTLC
   --routes value, -r value                a json array string in the format of the response of queryroutes that denotes which routes to use
   --skip_temp_err                         Whether the payment should be marked as failed when a temporary error occurred. Set it to true so the payment won't be failed unless a terminal error has occurred.
   

Messages

lnrpc.SendToRouteRequest

Source: lightning.proto

Field	gRPC Type	REST Type	REST Placement
payment_hash The payment hash to use for the HTLC. When using REST, this field must be encoded as base64.	bytes	string	unknown
payment_hash_string An optional hex-encoded payment hash to be used for the HTLC. Deprecated now that the REST gateway supports base64 encoding of bytes fields.	string	string	unknown
route Route that should be used to attempt to complete the payment.	Route	object	unknown

lnrpc.SendResponse

Source: lightning.proto

Field	gRPC Type	REST Type
payment_error	string	string
payment_preimage	bytes	string
payment_route	Route	object
payment_hash	bytes	string

Nested Messages

lnrpc.Route

Field	gRPC Type	REST Type
total_time_lock The cumulative (final) time lock across the entire route. This is the CLTV value that should be extended to the first hop in the route. All other hops will decrement the time-lock as advertised, leaving enough time for all hops to wait for or present the payment preimage to complete the payment.	uint32	integer
total_fees The sum of the fees paid at each hop within the final route. In the case of a one-hop payment, this value will be zero as we don't need to pay a fee to ourselves.	int64	string
total_amt The total amount of funds required to complete a payment over this route. This value includes the cumulative fees at each hop. As a result, the HTLC extended to the first-hop in the route will need to have at least this many satoshis, otherwise the route will fail at an intermediate node due to an insufficient amount of fees.	int64	string
hops Contains details concerning the specific forwarding details at each hop.	Hop[]	array
total_fees_msat The total fees in millisatoshis.	int64	string
total_amt_msat The total amount in millisatoshis.	int64	string

lnrpc.Hop

Field	gRPC Type	REST Type
chan_id The unique channel ID for the channel. The first 3 bytes are the block height, the next 3 the index within the block, and the last 2 bytes are the output index for the channel.	uint64	string
chan_capacity	int64	string
amt_to_forward	int64	string
fee	int64	string
expiry	uint32	integer
amt_to_forward_msat	int64	string
fee_msat	int64	string
pub_key An optional public key of the hop. If the public key is given, the payment can be executed without relying on a copy of the channel graph.	string	string
tlv_payload If set to true, then this hop will be encoded using the new variable length TLV format. Note that if any custom tlv_records below are specified, then this field MUST be set to true for them to be encoded properly.	bool	boolean
mpp_record An optional TLV record that signals the use of an MPP payment. If present, the receiver will enforce that the same mpp_record is included in the final hop payload of all non-zero payments in the HTLC set. If empty, a regular single-shot payment is or was attempted.	MPPRecord	object
amp_record An optional TLV record that signals the use of an AMP payment. If present, the receiver will treat all received payments including the same (payment_addr, set_id) pair as being part of one logical payment. The payment will be settled by XORing the root_share's together and deriving the child hashes and preimages according to BOLT XX. Must be used in conjunction with mpp_record.	AMPRecord	object
custom_records An optional set of key-value TLV records. This is useful within the context of the SendToRoute call as it allows callers to specify arbitrary K-V pairs to drop off at each hop within the onion.	CustomRecordsEntry[]	object
metadata The payment metadata to send along with the payment to the payee.	bytes	string

lnrpc.MPPRecord

Field	gRPC Type	REST Type
payment_addr A unique, random identifier used to authenticate the sender as the intended payer of a multi-path payment. The payment_addr must be the same for all subpayments, and match the payment_addr provided in the receiver's invoice. The same payment_addr must be used on all subpayments.	bytes	string
total_amt_msat The total amount in milli-satoshis being sent as part of a larger multi-path payment. The caller is responsible for ensuring subpayments to the same node and payment_hash sum exactly to total_amt_msat. The same total_amt_msat must be used on all subpayments.	int64	string

lnrpc.AMPRecord

Field	gRPC Type	REST Type
root_share	bytes	string
set_id	bytes	string
child_index	uint32	integer

lnrpc.Hop.CustomRecordsEntry

Field	gRPC Type	REST Type
key	uint64	unknown
value	bytes	unknown