OpenChannel

OpenChannel attempts to open a singly funded channel specified in the request to a remote peer. Users are able to specify a target number of blocks that the funding transaction should be confirmed in, or a manual fee rate to us for the funding transaction. If neither are specified, then a lax block confirmation target is used. Each OpenStatusUpdate will return the pending channel ID of the in-progress channel. Depending on the arguments specified in the OpenChannelRequest, this pending channel ID can then be used to manually progress the channel funding flow.

Source: lightning.proto

gRPC

info

This is a server-streaming RPC

rpc OpenChannel (OpenChannelRequest) returns (stream OpenStatusUpdate);

REST

HTTP Method	Path
POST	/v1/channels/stream

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 = {
  sat_per_vbyte: <uint64>,
  node_pubkey: <bytes>,
  node_pubkey_string: <string>,
  local_funding_amount: <int64>,
  push_sat: <int64>,
  target_conf: <int32>,
  sat_per_byte: <int64>,
  private: <bool>,
  min_htlc_msat: <int64>,
  remote_csv_delay: <uint32>,
  min_confs: <int32>,
  spend_unconfirmed: <bool>,
  close_address: <string>,
  funding_shim: <FundingShim>,
  remote_max_value_in_flight_msat: <uint64>,
  remote_max_htlcs: <uint32>,
  max_local_csv: <uint32>,
  commitment_type: <CommitmentType>,
  zero_conf: <bool>,
  scid_alias: <bool>,
  base_fee: <uint64>,
  fee_rate: <uint64>,
  use_base_fee: <bool>,
  use_fee_rate: <bool>,
  remote_chan_reserve_sat: <uint64>,
  fund_max: <bool>,
  memo: <string>,
  outpoints: <OutPoint>,
};
let call = client.openChannel(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:
//  {
//    "chan_pending": <PendingUpdate>,
//    "chan_open": <ChannelOpenUpdate>,
//    "psbt_fund": <ReadyForPsbtFunding>,
//    "pending_chan_id": <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)
request = lnrpc.OpenChannelRequest(
  sat_per_vbyte=<uint64>,
  node_pubkey=<bytes>,
  node_pubkey_string=<string>,
  local_funding_amount=<int64>,
  push_sat=<int64>,
  target_conf=<int32>,
  sat_per_byte=<int64>,
  private=<bool>,
  min_htlc_msat=<int64>,
  remote_csv_delay=<uint32>,
  min_confs=<int32>,
  spend_unconfirmed=<bool>,
  close_address=<string>,
  funding_shim=<FundingShim>,
  remote_max_value_in_flight_msat=<uint64>,
  remote_max_htlcs=<uint32>,
  max_local_csv=<uint32>,
  commitment_type=<CommitmentType>,
  zero_conf=<bool>,
  scid_alias=<bool>,
  base_fee=<uint64>,
  fee_rate=<uint64>,
  use_base_fee=<bool>,
  use_fee_rate=<bool>,
  remote_chan_reserve_sat=<uint64>,
  fund_max=<bool>,
  memo=<string>,
  outpoints=<OutPoint>,
)
for response in stub.OpenChannel(request):
  print(response)
# {
#    "chan_pending": <PendingUpdate>,
#    "chan_open": <ChannelOpenUpdate>,
#    "psbt_fund": <ReadyForPsbtFunding>,
#    "pending_chan_id": <bytes>,
# }

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 = {
  sat_per_vbyte: <string>, // <uint64> 
  node_pubkey: <string>, // <bytes> (base64 encoded)
  node_pubkey_string: <string>, // <string> 
  local_funding_amount: <string>, // <int64> 
  push_sat: <string>, // <int64> 
  target_conf: <integer>, // <int32> 
  sat_per_byte: <string>, // <int64> 
  private: <boolean>, // <bool> 
  min_htlc_msat: <string>, // <int64> 
  remote_csv_delay: <integer>, // <uint32> 
  min_confs: <integer>, // <int32> 
  spend_unconfirmed: <boolean>, // <bool> 
  close_address: <string>, // <string> 
  funding_shim: <object>, // <FundingShim> 
  remote_max_value_in_flight_msat: <string>, // <uint64> 
  remote_max_htlcs: <integer>, // <uint32> 
  max_local_csv: <integer>, // <uint32> 
  commitment_type: <string>, // <CommitmentType> 
  zero_conf: <boolean>, // <bool> 
  scid_alias: <boolean>, // <bool> 
  base_fee: <string>, // <uint64> 
  fee_rate: <string>, // <uint64> 
  use_base_fee: <boolean>, // <bool> 
  use_fee_rate: <boolean>, // <bool> 
  remote_chan_reserve_sat: <string>, // <uint64> 
  fund_max: <boolean>, // <bool> 
  memo: <string>, // <string> 
  outpoints: <array>, // <OutPoint> 
};
let options = {
  url: `https://${REST_HOST}/v1/channels/stream`,
  // 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:
//  {
//    "chan_pending": <object>, // <PendingUpdate> 
//    "chan_open": <object>, // <ChannelOpenUpdate> 
//    "psbt_fund": <object>, // <ReadyForPsbtFunding> 
//    "pending_chan_id": <string>, // <bytes> 
//  }



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

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

let ws = new WebSocket(`wss://${REST_HOST}/v1/channels/stream?method=POST`, {
  // Work-around for self-signed certificates.
  rejectUnauthorized: false,
  headers: {
    'Grpc-Metadata-Macaroon': fs.readFileSync(MACAROON_PATH).toString('hex'),
  },
});
let requestBody = {
  sat_per_vbyte: <uint64>, // <uint64> 
  node_pubkey: <bytes>, // <bytes> (base64 encoded)
  node_pubkey_string: <string>, // <string> 
  local_funding_amount: <int64>, // <int64> 
  push_sat: <int64>, // <int64> 
  target_conf: <int32>, // <int32> 
  sat_per_byte: <int64>, // <int64> 
  private: <bool>, // <bool> 
  min_htlc_msat: <int64>, // <int64> 
  remote_csv_delay: <uint32>, // <uint32> 
  min_confs: <int32>, // <int32> 
  spend_unconfirmed: <bool>, // <bool> 
  close_address: <string>, // <string> 
  funding_shim: <FundingShim>, // <FundingShim> 
  remote_max_value_in_flight_msat: <uint64>, // <uint64> 
  remote_max_htlcs: <uint32>, // <uint32> 
  max_local_csv: <uint32>, // <uint32> 
  commitment_type: <CommitmentType>, // <CommitmentType> 
  zero_conf: <bool>, // <bool> 
  scid_alias: <bool>, // <bool> 
  base_fee: <uint64>, // <uint64> 
  fee_rate: <uint64>, // <uint64> 
  use_base_fee: <bool>, // <bool> 
  use_fee_rate: <bool>, // <bool> 
  remote_chan_reserve_sat: <uint64>, // <uint64> 
  fund_max: <bool>, // <bool> 
  memo: <string>, // <string> 
  outpoints: <OutPoint>, // <OutPoint> 
};
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:
//  {
//    "chan_pending": <object>, // <PendingUpdate>
//    "chan_open": <object>, // <ChannelOpenUpdate>
//    "psbt_fund": <object>, // <ReadyForPsbtFunding>
//    "pending_chan_id": <string>, // <bytes>
//  }

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/channels/stream'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
data = {
  'sat_per_vbyte': <uint64>,
  'node_pubkey': base64.b64encode(<bytes>),
  'node_pubkey_string': <string>,
  'local_funding_amount': <int64>,
  'push_sat': <int64>,
  'target_conf': <int32>,
  'sat_per_byte': <int64>,
  'private': <bool>,
  'min_htlc_msat': <int64>,
  'remote_csv_delay': <uint32>,
  'min_confs': <int32>,
  'spend_unconfirmed': <bool>,
  'close_address': <string>,
  'funding_shim': <FundingShim>,
  'remote_max_value_in_flight_msat': <uint64>,
  'remote_max_htlcs': <uint32>,
  'max_local_csv': <uint32>,
  'commitment_type': <CommitmentType>,
  'zero_conf': <bool>,
  'scid_alias': <bool>,
  'base_fee': <uint64>,
  'fee_rate': <uint64>,
  'use_base_fee': <bool>,
  'use_fee_rate': <bool>,
  'remote_chan_reserve_sat': <uint64>,
  'fund_max': <bool>,
  'memo': <string>,
  'outpoints': <OutPoint>,
}
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)
# {
#    "chan_pending": <PendingUpdate>,
#    "chan_open": <ChannelOpenUpdate>,
#    "psbt_fund": <ReadyForPsbtFunding>,
#    "pending_chan_id": <bytes>,
# }

Shell

$ lncli openchannel --help

NAME:
   lncli openchannel - Open a channel to a node or an existing peer.

USAGE:
   lncli openchannel [command options] node-key local-amt push-amt

CATEGORY:
   Channels

DESCRIPTION:
   
  Attempt to open a new channel to an existing peer with the key node-key
  optionally blocking until the channel is 'open'.

  One can also connect to a node before opening a new channel to it by
  setting its host:port via the --connect argument. For this to work,
  the node_key must be provided, rather than the peer_id. This is
  optional.

  The channel will be initialized with local-amt satoshis locally and
  push-amt satoshis for the remote node. Note that the push-amt is
  deducted from the specified local-amt which implies that the local-amt
  must be greater than the push-amt. Also note that specifying push-amt
  means you give that amount to the remote node as part of the channel
  opening. Once the channel is open, a channelPoint (txid:vout) of the
  funding output is returned.

  If the remote peer supports the option upfront shutdown feature bit
  (query listpeers to see their supported feature bits), an address to
  enforce payout of funds on cooperative close can optionally be provided.
  Note that if you set this value, you will not be able to cooperatively
  close out to another address.

  One can manually set the fee to be used for the funding transaction via
  either the --conf_target or --sat_per_vbyte arguments. This is
  optional.

  One can also specify a short string memo to record some useful
  information about the channel using the --memo argument. This is stored
  locally only, and is purely for reference. It has no bearing on the
  channel's operation. Max allowed length is 500 characters.

OPTIONS:
   --node_key value                         the identity public key of the target node/peer serialized in compressed format
   --connect value                          (optional) the host:port of the target node
   --local_amt value                        the number of satoshis the wallet should commit to the channel (default: 0)
   --fundmax                                if set, the wallet will attempt to commit the maximum possible local amount to the channel. This must not be set at the same time as local_amt
   --utxo value                             a utxo specified as outpoint(tx:idx) which will be used to fund a channel. This flag can be repeatedly used to fund a channel with a selection of utxos. The selected funds can either be entirely spent by specifying the fundmax flag or partially by selecting a fraction of the sum of the outpoints in local_amt
   --base_fee_msat value                    the base fee in milli-satoshis that will be charged for each forwarded HTLC, regardless of payment size (default: 0)
   --fee_rate_ppm value                     the fee rate ppm (parts per million) that will be charged proportionally based on the value of each forwarded HTLC, the lowest possible rate is 0 with a granularity of 0.000001 (millionths) (default: 0)
   --push_amt value                         the number of satoshis to give the remote side as part of the initial commitment state, this is equivalent to first opening a channel and sending the remote party funds, but done all in one step (default: 0)
   --block                                  block and wait until the channel is fully open
   --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)
   --private                                make the channel private, such that it won't be announced to the greater network, and nodes other than the two channel endpoints must be explicitly told about it to be able to route through it
   --min_htlc_msat value                    (optional) the minimum value we will require for incoming HTLCs on the channel (default: 0)
   --remote_csv_delay value                 (optional) the number of blocks we will require our channel counterparty to wait before accessing its funds in case of unilateral close. If this is not set, we will scale the value according to the channel size (default: 0)
   --max_local_csv value                    (optional) the maximum number of blocks that we will allow the remote peer to require we wait before accessing our funds in the case of a unilateral close. (default: 0)
   --min_confs value                        (optional) the minimum number of confirmations each one of your outputs used for the funding transaction must satisfy (default: 1)
   --close_address value                    (optional) an address to enforce payout of our funds to on cooperative close. Note that if this value is set on channel open, you will *not* be able to cooperatively close to a different address.
   --psbt                                   start an interactive mode that initiates funding through a partially signed bitcoin transaction (PSBT), allowing the channel funds to be added and signed from a hardware or other offline device.
   --base_psbt value                        when using the interactive PSBT mode to open a new channel, use this base64 encoded PSBT as a base and add the new channel output to it instead of creating a new, empty one.
   --no_publish                             when using the interactive PSBT mode to open multiple channels in a batch, this flag instructs lnd to not publish the full batch transaction just yet. For safety reasons this flag should be set for each of the batch's transactions except the very last
   --remote_max_value_in_flight_msat value  (optional) the maximum value in msat that can be pending within the channel at any given time (default: 0)
   --channel_type value                     (optional) the type of channel to propose to the remote peer ("tweakless", "anchors", "taproot")
   --zero_conf                              (optional) whether a zero-conf channel open should be attempted.
   --scid_alias                             (optional) whether a scid-alias channel type should be negotiated.
   --remote_reserve_sats value              (optional) the minimum number of satoshis we require the remote node to keep as a direct payment. If not specified, a default of 1% of the channel capacity will be used. (default: 0)
   --memo value                             (optional) a note-to-self containing some useful
                                                  information about the channel. This is stored
                                                  locally only, and is purely for reference. It
                                                  has no bearing on the channel's operation. Max
                                                  allowed length is 500 characters
   

Messages

lnrpc.OpenChannelRequest

Source: lightning.proto

Field	gRPC Type	REST Type	REST Placement
sat_per_vbyte A manual fee rate set in sat/vbyte that should be used when crafting the funding transaction.	uint64	string	body
node_pubkey The pubkey of the node to open a channel with. When using REST, this field must be encoded as base64.	bytes	string	body
node_pubkey_stringdeprecated The hex encoded pubkey of the node to open a channel with. Deprecated now that the REST gateway supports base64 encoding of bytes fields.	string	string	body
local_funding_amount The number of satoshis the wallet should commit to the channel	int64	string	body
push_sat The number of satoshis to push to the remote side as part of the initial commitment state	int64	string	body
target_conf The target number of blocks that the funding transaction should be confirmed by.	int32	integer	body
sat_per_bytedeprecated Deprecated, use sat_per_vbyte. A manual fee rate set in sat/vbyte that should be used when crafting the funding transaction.	int64	string	body
private Whether this channel should be private, not announced to the greater network.	bool	boolean	body
min_htlc_msat The minimum value in millisatoshi we will require for incoming HTLCs on the channel.	int64	string	body
remote_csv_delay The delay we require on the remote's commitment transaction. If this is not set, it will be scaled automatically with the channel size.	uint32	integer	body
min_confs The minimum number of confirmations each one of your outputs used for the funding transaction must satisfy.	int32	integer	body
spend_unconfirmed Whether unconfirmed outputs should be used as inputs for the funding transaction.	bool	boolean	body
close_address Close address is an optional address which specifies the address to which funds should be paid out to upon cooperative close. This field may only be set if the peer supports the option upfront feature bit (call listpeers to check). The remote peer will only accept cooperative closes to this address if it is set. Note: If this value is set on channel creation, you will not be able to cooperatively close out to a different address.	string	string	body
funding_shim Funding shims are an optional argument that allow the caller to intercept certain funding functionality. For example, a shim can be provided to use a particular key for the commitment key (ideally cold) rather than use one that is generated by the wallet as normal, or signal that signing will be carried out in an interactive manner (PSBT based).	FundingShim	object	body
remote_max_value_in_flight_msat The maximum amount of coins in millisatoshi that can be pending within the channel. It only applies to the remote party.	uint64	string	body
remote_max_htlcs The maximum number of concurrent HTLCs we will allow the remote party to add to the commitment transaction.	uint32	integer	body
max_local_csv Max local csv is the maximum csv delay we will allow for our own commitment transaction.	uint32	integer	body
commitment_type The explicit commitment type to use. Note this field will only be used if the remote peer supports explicit channel negotiation.	CommitmentType	string	body
zero_conf If this is true, then a zero-conf channel open will be attempted.	bool	boolean	body
scid_alias If this is true, then an option-scid-alias channel-type open will be attempted.	bool	boolean	body
base_fee The base fee charged regardless of the number of milli-satoshis sent.	uint64	string	body
fee_rate The fee rate in ppm (parts per million) that will be charged in proportion of the value of each forwarded HTLC.	uint64	string	body
use_base_fee If use_base_fee is true the open channel announcement will update the channel base fee with the value specified in base_fee. In the case of a base_fee of 0 use_base_fee is needed downstream to distinguish whether to use the default base fee value specified in the config or 0.	bool	boolean	body
use_fee_rate If use_fee_rate is true the open channel announcement will update the channel fee rate with the value specified in fee_rate. In the case of a fee_rate of 0 use_fee_rate is needed downstream to distinguish whether to use the default fee rate value specified in the config or 0.	bool	boolean	body
remote_chan_reserve_sat The number of satoshis we require the remote peer to reserve. This value, if specified, must be above the dust limit and below 20% of the channel capacity.	uint64	string	body
fund_max If set, then lnd will attempt to commit all the coins under control of the internal wallet to open the channel, and the LocalFundingAmount field must be zero and is ignored.	bool	boolean	body
memo An optional note-to-self to go along with the channel containing some useful information. This is only ever stored locally and in no way impacts the channel's operation.	string	string	body
outpoints A list of selected outpoints that are allocated for channel funding.	OutPoint[]	array	body

lnrpc.OpenStatusUpdate

Source: lightning.proto

Field	gRPC Type	REST Type
chan_pending Signals that the channel is now fully negotiated and the funding transaction published.	PendingUpdate	object
chan_open Signals that the channel's funding transaction has now reached the required number of confirmations on chain and can be used.	ChannelOpenUpdate	object
psbt_fund Signals that the funding process has been suspended and the construction of a PSBT that funds the channel PK script is now required.	ReadyForPsbtFunding	object
pending_chan_id The pending channel ID of the created channel. This value may be used to further the funding flow manually via the FundingStateStep method.	bytes	string

Nested Messages

lnrpc.ChannelOpenUpdate

Field	gRPC Type	REST Type
channel_point	ChannelPoint	object

lnrpc.ChannelPoint

Field	gRPC Type	REST Type
funding_txid_bytes Txid of the funding transaction. When using REST, this field must be encoded as base64.	bytes	string
funding_txid_str Hex-encoded string representing the byte-reversed hash of the funding transaction.	string	string
output_index The index of the output of the funding transaction	uint32	integer

lnrpc.ChanPointShim

Field	gRPC Type	REST Type
amt The size of the pre-crafted output to be used as the channel point for this channel funding.	int64	string
chan_point The target channel point to refrence in created commitment transactions.	ChannelPoint	object
local_key Our local key to use when creating the multi-sig output.	KeyDescriptor	object
remote_key The key of the remote party to use when creating the multi-sig output.	bytes	string
pending_chan_id If non-zero, then this will be used as the pending channel ID on the wire protocol to initate the funding request. This is an optional field, and should only be set if the responder is already expecting a specific pending channel ID.	bytes	string
thaw_height This uint32 indicates if this channel is to be considered 'frozen'. A frozen channel does not allow a cooperative channel close by the initiator. The thaw_height is the height that this restriction stops applying to the channel. The height can be interpreted in two ways: as a relative height if the value is less than 500,000, or as an absolute height otherwise.	uint32	integer
musig2 Indicates that the funding output is using a MuSig2 multi-sig output.	bool	boolean

lnrpc.FundingShim

Field	gRPC Type	REST Type
chan_point_shim A channel shim where the channel point was fully constructed outside of lnd's wallet and the transaction might already be published.	ChanPointShim	object
psbt_shim A channel shim that uses a PSBT to fund and sign the channel funding transaction.	PsbtShim	object

lnrpc.KeyDescriptor

Field	gRPC Type	REST Type
raw_key_bytes The raw bytes of the key being identified.	bytes	string
key_loc The key locator that identifies which key to use for signing.	KeyLocator	object

lnrpc.KeyLocator

Field	gRPC Type	REST Type
key_family The family of key being identified.	int32	integer
key_index The precise index of the key being identified.	int32	integer

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

lnrpc.PendingUpdate

Field	gRPC Type	REST Type
txid	bytes	string
output_index	uint32	integer

lnrpc.PsbtShim

Field	gRPC Type	REST Type
pending_chan_id A unique identifier of 32 random bytes that will be used as the pending channel ID to identify the PSBT state machine when interacting with it and on the wire protocol to initiate the funding request.	bytes	string
base_psbt An optional base PSBT the new channel output will be added to. If this is non-empty, it must be a binary serialized PSBT.	bytes	string
no_publish If a channel should be part of a batch (multiple channel openings in one transaction), it can be dangerous if the whole batch transaction is published too early before all channel opening negotiations are completed. This flag prevents this particular channel from broadcasting the transaction after the negotiation with the remote peer. In a batch of channel openings this flag should be set to true for every channel but the very last.	bool	boolean

lnrpc.ReadyForPsbtFunding

Field	gRPC Type	REST Type
funding_address The P2WSH address of the channel funding multisig address that the below specified amount in satoshis needs to be sent to.	string	string
funding_amount The exact amount in satoshis that needs to be sent to the above address to fund the pending channel.	int64	string
psbt A raw PSBT that contains the pending channel output. If a base PSBT was provided in the PsbtShim, this is the base PSBT with one additional output. If no base PSBT was specified, this is an otherwise empty PSBT with exactly one output.	bytes	string

Enums

lnrpc.CommitmentType

Name	Number
UNKNOWN_COMMITMENT_TYPE Returned when the commitment type isn't known or unavailable.	0
LEGACY A channel using the legacy commitment format having tweaked to_remote keys.	1
STATIC_REMOTE_KEY A channel that uses the modern commitment format where the key in the output of the remote party does not change each state. This makes back up and recovery easier as when the channel is closed, the funds go directly to that key.	2
ANCHORS A channel that uses a commitment format that has anchor outputs on the commitments, allowing fee bumping after a force close transaction has been broadcast.	3
SCRIPT_ENFORCED_LEASE A channel that uses a commitment type that builds upon the anchors commitment format, but in addition requires a CLTV clause to spend outputs paying to the channel initiator. This is intended for use on leased channels to guarantee that the channel initiator has no incentives to close a leased channel before its maturity date.	4
SIMPLE_TAPROOT A channel that uses musig2 for the funding output, and the new tapscript features where relevant.	5
SIMPLE_TAPROOT_OVERLAY Identical to the SIMPLE_TAPROOT channel type, but with extra functionality. This channel type also commits to additional meta data in the tapscript leaves for the scripts in a channel.	6