SendCoins

SendCoins executes a request to send coins to a particular address. Unlike SendMany, this RPC call only allows creating a single output at a time. If neither target_conf, or sat_per_vbyte are set, then the internal wallet will consult its fee model to determine a fee for the default confirmation target.

Source: lightning.proto

gRPC

rpc SendCoins (SendCoinsRequest) returns (SendCoinsResponse);

REST

HTTP Method	Path
POST	/v1/transactions

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 = {
  addr: <string>,
  amount: <int64>,
  target_conf: <int32>,
  sat_per_vbyte: <uint64>,
  sat_per_byte: <int64>,
  send_all: <bool>,
  label: <string>,
  min_confs: <int32>,
  spend_unconfirmed: <bool>,
  coin_selection_strategy: <CoinSelectionStrategy>,
  outpoints: <OutPoint>,
};
client.sendCoins(request, function(err, response) {
  console.log(response);
});
// Console output:
//  {
//    "txid": <string>,
//  }

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)
request = lnrpc.SendCoinsRequest(
  addr=<string>,
  amount=<int64>,
  target_conf=<int32>,
  sat_per_vbyte=<uint64>,
  sat_per_byte=<int64>,
  send_all=<bool>,
  label=<string>,
  min_confs=<int32>,
  spend_unconfirmed=<bool>,
  coin_selection_strategy=<CoinSelectionStrategy>,
  outpoints=<OutPoint>,
)
response = stub.SendCoins(request)
print(response)
# {
#    "txid": <string>,
# }

REST

Javascript

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

const REST_HOST = 'localhost:8080'
const MACAROON_PATH = 'LND_DIR/data/chain/bitcoin/regtest/admin.macaroon'

let requestBody = {
  addr: <string>, // <string> 
  amount: <string>, // <int64> 
  target_conf: <integer>, // <int32> 
  sat_per_vbyte: <string>, // <uint64> 
  sat_per_byte: <string>, // <int64> 
  send_all: <boolean>, // <bool> 
  label: <string>, // <string> 
  min_confs: <integer>, // <int32> 
  spend_unconfirmed: <boolean>, // <bool> 
  coin_selection_strategy: <string>, // <CoinSelectionStrategy> 
  outpoints: <array>, // <OutPoint> 
};
let options = {
  url: `https://${REST_HOST}/v1/transactions`,
  // 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:
//  {
//    "txid": <string>, // <string> 
//  }

Python

import base64, codecs, json, requests

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

url = f'https://{REST_HOST}/v1/transactions'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
data = {
  'addr': <string>,
  'amount': <int64>,
  'target_conf': <int32>,
  'sat_per_vbyte': <uint64>,
  'sat_per_byte': <int64>,
  'send_all': <bool>,
  'label': <string>,
  'min_confs': <int32>,
  'spend_unconfirmed': <bool>,
  'coin_selection_strategy': <CoinSelectionStrategy>,
  'outpoints': <OutPoint>,
}
r = requests.post(url, headers=headers, data=json.dumps(data), verify=TLS_PATH)
print(r.json())
# {
#    "txid": <string>,
# }

Shell

$ lncli sendcoins --help

NAME:
   lncli sendcoins - Send bitcoin on-chain to an address.

USAGE:
   lncli sendcoins [command options] addr amt

CATEGORY:
   On-chain

DESCRIPTION:
   
  Send amt coins in satoshis to the base58 or bech32 encoded bitcoin address addr.

  Fees used when sending the transaction can be specified via the --conf_target, or
  --sat_per_vbyte optional flags.

  Positional arguments and flags can be used interchangeably but not at the same time!
  

OPTIONS:
   --addr value                     the base58 or bech32 encoded bitcoin address to send coins to on-chain
   --sweepall                       if set, then the amount field should be unset. This indicates that the wallet will attempt to sweep all outputs within the wallet or all funds in select utxos (when supplied) to the target address
   --amt value                      the number of bitcoin denominated in satoshis to send (default: 0)
   --conf_target value              (optional) the number of blocks that the transaction *should* confirm in, will be used for fee estimation (default: 0)
   --sat_per_vbyte value            (optional) a manual fee expressed in sat/vbyte that should be used when crafting the transaction (default: 0)
   --min_confs value                (optional) the minimum number of confirmations each one of your outputs used for the transaction must satisfy (default: 1)
   --force, -f                      if set, the transaction will be broadcast without asking for confirmation; this is set to true by default if stdout is not a terminal avoid breaking existing shell scripts
   --coin_selection_strategy value  (optional) the strategy to use for selecting coins. Possible values are 'largest', 'random', or 'global-config'. If either 'largest' or 'random' is specified, it will override the globally configured strategy in lnd.conf (default: "global-config")
   --utxo value                     a utxo specified as outpoint(tx:idx) which will be used as input for the transaction. This flag can be repeatedly used to specify multiple utxos as inputs. The selected utxos can either be entirely spent by specifying the sweepall flag or a specified amount can be spent in the utxos through the amt flag
   --label value                    (optional) a label for the transaction
   

Messages

lnrpc.SendCoinsRequest

Source: lightning.proto

Field	gRPC Type	REST Type	REST Placement
addr The address to send coins to	string	string	body
amount The amount in satoshis to send	int64	string	body
target_conf The target number of blocks that this transaction should be confirmed by.	int32	integer	body
sat_per_vbyte A manual fee rate set in sat/vbyte that should be used when crafting the transaction.	uint64	string	body
sat_per_bytedeprecated Deprecated, use sat_per_vbyte. A manual fee rate set in sat/vbyte that should be used when crafting the transaction.	int64	string	body
send_all If set, the amount field should be unset. It indicates lnd will send all wallet coins or all selected coins to the specified address.	bool	boolean	body
label An optional label for the transaction, limited to 500 characters.	string	string	body
min_confs The minimum number of confirmations each one of your outputs used for the transaction must satisfy.	int32	integer	body
spend_unconfirmed Whether unconfirmed outputs should be used as inputs for the transaction.	bool	boolean	body
coin_selection_strategy The strategy to use for selecting coins.	CoinSelectionStrategy	string	body
outpoints A list of selected outpoints as inputs for the transaction.	OutPoint[]	array	body

lnrpc.SendCoinsResponse

Source: lightning.proto

Field	gRPC Type	REST Type
txid The transaction ID of the transaction	string	string

Nested Messages

lnrpc.OutPoint

Field	gRPC Type	REST Type
txid_bytes Raw bytes representing the transaction id.	bytes	string
txid_str Reversed, hex-encoded string representing the transaction id.	string	string
output_index The index of the output on the transaction.	uint32	integer

Enums

lnrpc.CoinSelectionStrategy

Name	Number
STRATEGY_USE_GLOBAL_CONFIG Use the coin selection strategy defined in the global configuration (lnd.conf).	0
STRATEGY_LARGEST Select the largest available coins first during coin selection.	1
STRATEGY_RANDOM Randomly select the available coins during coin selection.	2