SendPayment

SendPayment is a wrapper around lnd's routerrpc.SendPaymentV2 RPC method with asset specific parameters. It allows RPC users to send asset keysend payments (direct payments) or payments to an invoice with a specified asset amount.

Source: tapchannelrpc/tapchannel.proto

gRPC

info

This is a server-streaming RPC

rpc SendPayment (SendPaymentRequest) returns (stream SendPaymentResponse);

REST

HTTP Method	Path
POST	/v1/taproot-assets/channels/send-payment

Code Samples

gRPC

Javascript

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

const GRPC_HOST = 'localhost:10029'
const MACAROON_PATH = 'TAPROOT-ASSETS_DIR/regtest/taproot-assets.macaroon'
const TLS_PATH = 'TAPROOT-ASSETS_DIR/tls.cert'

const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true,
};
const packageDefinition = protoLoader.loadSync('tapchannelrpc/tapchannel.proto', loaderOptions);
const tapchannelrpc = grpc.loadPackageDefinition(packageDefinition).tapchannelrpc;
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 tapchannelrpc.TaprootAssetChannels(GRPC_HOST, creds);
let request = {
  asset_id: <bytes>,
  asset_amount: <uint64>,
  peer_pubkey: <bytes>,
  payment_request: <SendPaymentRequest>,
  rfq_id: <bytes>,
  allow_overpay: <bool>,
  group_key: <bytes>,
};
let call = client.sendPayment(request);
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.
});
// Console output:
//  {
//    "accepted_sell_order": <PeerAcceptedSellQuote>,
//    "payment_result": <Payment>,
//  }

Python

import codecs, grpc, os
# Generate the following 2 modules by compiling the tapchannelrpc/tapchannel.proto with the grpcio-tools.
# See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
import tapchannel_pb2 as tapchannelrpc, tapchannel_pb2_grpc as tapchannelstub

GRPC_HOST = 'localhost:10029'
MACAROON_PATH = 'TAPROOT-ASSETS_DIR/regtest/taproot-assets.macaroon'
TLS_PATH = 'TAPROOT-ASSETS_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 = tapchannelstub.TaprootAssetChannelsStub(channel)
request = tapchannelrpc.SendPaymentRequest(
  asset_id=<bytes>,
  asset_amount=<uint64>,
  peer_pubkey=<bytes>,
  payment_request=<SendPaymentRequest>,
  rfq_id=<bytes>,
  allow_overpay=<bool>,
  group_key=<bytes>,
)
for response in stub.SendPayment(request):
  print(response)
# {
#    "accepted_sell_order": <PeerAcceptedSellQuote>,
#    "payment_result": <Payment>,
# }

REST

Javascript

const fs = require('fs');
const request = require('request');

const REST_HOST = 'localhost:8089'
const MACAROON_PATH = 'TAPROOT-ASSETS_DIR/regtest/taproot-assets.macaroon'

let requestBody = {
  asset_id: <string>, // <bytes> (base64 encoded)
  asset_amount: <string>, // <uint64> 
  peer_pubkey: <string>, // <bytes> (base64 encoded)
  payment_request: <object>, // <SendPaymentRequest> 
  rfq_id: <string>, // <bytes> (base64 encoded)
  allow_overpay: <boolean>, // <bool> 
  group_key: <string>, // <bytes> (base64 encoded)
};
let options = {
  url: `https://${REST_HOST}/v1/taproot-assets/channels/send-payment`,
  // Work-around for self-signed certificates.
  rejectUnauthorized: false,
  json: true,
  headers: {
    'Grpc-Metadata-macaroon': fs.readFileSync(MACAROON_PATH).toString('hex'),
  },
  form: JSON.stringify(requestBody),
}
request.post(options, function(error, response, body) {
  console.log(body);
});
// Console output:
//  {
//    "accepted_sell_order": <object>, // <PeerAcceptedSellQuote> 
//    "payment_result": <object>, // <Payment> 
//  }



// --------------------------
// Example with websockets:
// --------------------------
const WebSocket = require('ws');
const fs = require('fs');

const REST_HOST = 'localhost:8089'
const MACAROON_PATH = 'TAPROOT-ASSETS_DIR/regtest/taproot-assets.macaroon'

let ws = new WebSocket(`wss://${REST_HOST}/v1/taproot-assets/channels/send-payment?method=POST`, {
  // Work-around for self-signed certificates.
  rejectUnauthorized: false,
  headers: {
    'Grpc-Metadata-Macaroon': fs.readFileSync(MACAROON_PATH).toString('hex'),
  },
});
let requestBody = {
  asset_id: <bytes>, // <bytes> (base64 encoded)
  asset_amount: <uint64>, // <uint64> 
  peer_pubkey: <bytes>, // <bytes> (base64 encoded)
  payment_request: <SendPaymentRequest>, // <SendPaymentRequest> 
  rfq_id: <bytes>, // <bytes> (base64 encoded)
  allow_overpay: <bool>, // <bool> 
  group_key: <bytes>, // <bytes> (base64 encoded)
};
ws.on('open', function() {
    ws.send(JSON.stringify(requestBody));
});
ws.on('error', function(err) {
    console.log('Error: ' + err);
});
ws.on('message', function(body) {
    console.log(body);
});
// Console output:
//  {
//    "accepted_sell_order": <object>, // <PeerAcceptedSellQuote>
//    "payment_result": <object>, // <Payment>
//  }

Python

import base64, codecs, json, requests

REST_HOST = 'localhost:8089'
MACAROON_PATH = 'TAPROOT-ASSETS_DIR/regtest/taproot-assets.macaroon'
TLS_PATH = 'TAPROOT-ASSETS_DIR/tls.cert'

url = f'https://{REST_HOST}/v1/taproot-assets/channels/send-payment'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
data = {
  'asset_id': base64.b64encode(<bytes>),
  'asset_amount': <uint64>,
  'peer_pubkey': base64.b64encode(<bytes>),
  'payment_request': <SendPaymentRequest>,
  'rfq_id': base64.b64encode(<bytes>),
  'allow_overpay': <bool>,
  'group_key': base64.b64encode(<bytes>),
}
r = requests.post(url, headers=headers, stream=True, data=json.dumps(data), verify=TLS_PATH)
for raw_response in r.iter_lines():
  json_response = json.loads(raw_response)
  print(json_response)
# {
#    "accepted_sell_order": <PeerAcceptedSellQuote>,
#    "payment_result": <Payment>,
# }

Shell

$ litcli ln sendpayment --help

NAME:
   litcli ln sendpayment - Send a keysend payment to a direct peer over Lightning, potentially using a multi-asset channel.

USAGE:
   litcli ln sendpayment [command options] --keysend --dest=N [--asset_id=X | --group_key=X] --asset_amount=Y [--rfq_peer_pubkey=Z] [--allow_overpay]

CATEGORY:
   Payments

DESCRIPTION:
   
  Send a keysend asset payment over the Lightning Network. A keysend
  payment is an invoice-less payment that is sent to a node using its
  public key, specified by the --dest argument.

  Asset keysend payments are only supported to be sent to direct peers.
  Multi-hop asset payments must be sent using invoices and the
  corresponding 'ln payinvoice' subcommand.

  To send a multi-asset LN keysend payment, the --asset_id=X or
  --group_key=X argument can be used to specify the asset to use.

  Note that this command will only work with the --keysend argument set.
  

OPTIONS:
   --keysend                    will generate a pre-image and encode it in the sphinx packet, a dest must be set
   --dest value, -d value       the compressed identity pubkey of the payment recipient
   --asset_id value             the asset ID of the asset to use when sending payments with assets; cannot be used at the same time as --group_key
   --group_key value            the group key of the asset to use when sending payments with assets; cannot be used at the same time as --asset_id
   --asset_amount value         the amount of the asset to send in the asset keysend payment (default: 0)
   --rfq_peer_pubkey value      (optional) the public key of the peer to ask for a quote when converting from assets to sats; must be set if there are multiple channels with the same asset ID present
   --allow_overpay              allow sending asset payments that are uneconomical because the required non-dust amount for an asset carrier HTLC plus one asset unit is higher than the total invoice/payment amount that arrives at the destination; meaning that the total amount sent exceeds the total amount received plus routing fees
   --amt value, -a value        number of satoshis to send (default: 0)
   --final_cltv_delta value     the number of blocks the last hop has to reveal the preimage (default: 0)
   --pay_addr value             the payment address of the generated invoice
   --timeout value              the maximum amount of time we should spend trying to fulfill the payment, failing after the timeout has elapsed (default: 1m0s)
   --outgoing_chan_id value     short channel id of the outgoing channel to use for the first hop of the payment; can be specified multiple times in the same command
   --force, -f                  will skip payment request confirmation
   --max_parts value            the maximum number of partial payments that may be used (default: 16)
   --max_shard_size_sat value   the largest payment split that should be attempted if payment splitting is required to attempt a payment, specified in satoshis (default: 0)
   --max_shard_size_msat value  the largest payment split that should be attempted if payment splitting is required to attempt a payment, specified in milli-satoshis (default: 0)
   --amp                        if set to true, then AMP will be used to complete the payment
   

Messages

tapchannelrpc.SendPaymentRequest

Source: tapchannelrpc/tapchannel.proto

Field	gRPC Type	REST Type	REST Placement
asset_id The asset ID to use for the payment. This must be set for both invoice and keysend payments, unless RFQ negotiation was already done beforehand and payment_request.first_hop_custom_records already contains valid RFQ data. Mutually exclusive to group_key.	bytes	string	body
asset_amount The asset amount to send in a keysend payment. This amount is ignored for invoice payments as the asset amount is negotiated through RFQ with the peer, depending on the invoice amount. This can also be left unset if RFQ negotiation was already done beforehand and payment_request.first_hop_custom_records already contains valid RFQ data.	uint64	string	body
peer_pubkey The node identity public key of the peer to ask for a quote for sending out the assets and converting them to satoshis. This must be specified if there are multiple channels with the given asset ID.	bytes	string	body
payment_request The full lnd payment request to send. All fields behave the same way as they do for lnd's routerrpc.SendPaymentV2 RPC method (see the API docs at https://lightning.engineering/api-docs/api/lnd/router/send-payment-v2 for more details). To send a keysend payment, the payment_request.dest_custom_records must contain a valid keysend record (key 5482373484 and a 32-byte preimage that corresponds to the payment hash).	SendPaymentRequest	object	body
rfq_id The rfq id to use for this payment. If the user sets this value then the payment will immediately be dispatched, skipping the rfq negotiation phase, and using the following rfq id instead.	bytes	string	body
allow_overpay If a small invoice should be paid that is below the amount that always needs to be sent out to carry a single asset unit, then by default the payment is rejected. If this flag is set, then the payment will be allowed to proceed, even if it is uneconomical, meaning that more sats are sent out to the network than the invoice amount plus routing fees require to be paid.	bool	boolean	body
group_key The group key which dictates which assets may be used for this payment. Mutually exclusive to asset_id.	bytes	string	body

tapchannelrpc.SendPaymentResponse

Source: tapchannelrpc/tapchannel.proto

Field	gRPC Type	REST Type
accepted_sell_order In case channel assets need to be swapped to another asset, an asset sell order is negotiated with the channel peer. The result will be the first message in the response stream. If no swap is needed, the payment results will be streamed directly.	PeerAcceptedSellQuote	object
payment_result The payment result of a single payment attempt. Multiple attempts may be returned per payment request until either the payment succeeds or the payment times out.	Payment	object

Nested Messages

rfqrpc.FixedPoint

Field	gRPC Type	REST Type
coefficient The coefficient is the fractional value scaled-up as an integer. This integer is represented as a string as it may be too large to fit in a uint64.	string	string
scale The scale is the component that determines how many decimal places the coefficient should be divided by to obtain the fractional value.	uint32	integer

rfqrpc.PeerAcceptedSellQuote

Field	gRPC Type	REST Type
peer Quote counterparty peer.	string	string
id The unique identifier of the quote request.	bytes	string
scid scid is the short channel ID of the channel over which the payment for the quote should be made.	uint64	string
asset_amount asset_amount is the amount of the subject asset.	uint64	string
bid_asset_rate bid_asset_rate is the asset to BTC conversion rate represented as a fixed-point number.	FixedPoint	object
expiry The unix timestamp in seconds after which the quote is no longer valid.	uint64	string
min_transportable_msat The minimum amount of milli-satoshis that need to be sent out in order to transport a single asset unit over the Lightning Network with the given rate. This is the base amount of 354,000 milli-satoshi (the minimum amount for a non-dust HTLC) plus the equivalent of one asset unit in milli-satoshis.	uint64	string