RegisterConfirmationsNtfn

RegisterConfirmationsNtfn is a synchronous response-streaming RPC that registers an intent for a client to be notified once a confirmation request has reached its required number of confirmations on-chain.

A confirmation request must have a valid output script. It is also possible to give a transaction ID. If the transaction ID is not set, a notification is sent once the output script confirms. If the transaction ID is also set, a notification is sent once the output script confirms in the given transaction.

Source: chainrpc/chainnotifier.proto

gRPC

info

This is a server-streaming RPC

rpc RegisterConfirmationsNtfn (ConfRequest) returns (stream ConfEvent);

REST

HTTP Method	Path
POST	/v2/chainnotifier/register/confirmations

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', 'chainrpc/chainnotifier.proto'], loaderOptions);
const chainrpc = grpc.loadPackageDefinition(packageDefinition).chainrpc;
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 chainrpc.ChainNotifier(GRPC_HOST, creds);
let request = {
  txid: <bytes>,
  script: <bytes>,
  num_confs: <uint32>,
  height_hint: <uint32>,
  include_block: <bool>,
};
let call = client.registerConfirmationsNtfn(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:
//  {
//    "conf": <ConfDetails>,
//    "reorg": <Reorg>,
//  }

Python

import codecs, grpc, os
# Generate the following 2 modules by compiling the chainrpc/chainnotifier.proto with the grpcio-tools.
# See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
import chainnotifier_pb2 as chainrpc, chainnotifier_pb2_grpc as chainnotifierstub

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 = chainnotifierstub.ChainNotifierStub(channel)
request = chainrpc.ConfRequest(
  txid=<bytes>,
  script=<bytes>,
  num_confs=<uint32>,
  height_hint=<uint32>,
  include_block=<bool>,
)
for response in stub.RegisterConfirmationsNtfn(request):
  print(response)
# {
#    "conf": <ConfDetails>,
#    "reorg": <Reorg>,
# }

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 = {
  txid: <string>, // <bytes> (base64 encoded)
  script: <string>, // <bytes> (base64 encoded)
  num_confs: <integer>, // <uint32> 
  height_hint: <integer>, // <uint32> 
  include_block: <boolean>, // <bool> 
};
let options = {
  url: `https://${REST_HOST}/v2/chainnotifier/register/confirmations`,
  // 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:
//  {
//    "conf": <object>, // <ConfDetails> 
//    "reorg": <object>, // <Reorg> 
//  }



// --------------------------
// 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}/v2/chainnotifier/register/confirmations?method=POST`, {
  // Work-around for self-signed certificates.
  rejectUnauthorized: false,
  headers: {
    'Grpc-Metadata-Macaroon': fs.readFileSync(MACAROON_PATH).toString('hex'),
  },
});
let requestBody = {
  txid: <bytes>, // <bytes> (base64 encoded)
  script: <bytes>, // <bytes> (base64 encoded)
  num_confs: <uint32>, // <uint32> 
  height_hint: <uint32>, // <uint32> 
  include_block: <bool>, // <bool> 
};
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:
//  {
//    "conf": <object>, // <ConfDetails>
//    "reorg": <object>, // <Reorg>
//  }

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}/v2/chainnotifier/register/confirmations'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
data = {
  'txid': base64.b64encode(<bytes>),
  'script': base64.b64encode(<bytes>),
  'num_confs': <uint32>,
  'height_hint': <uint32>,
  'include_block': <bool>,
}
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)
# {
#    "conf": <ConfDetails>,
#    "reorg": <Reorg>,
# }

Shell

# There is no CLI command for this RPC

Messages

chainrpc.ConfRequest

Source: chainrpc/chainnotifier.proto

Field	gRPC Type	REST Type	REST Placement
txid The transaction hash for which we should request a confirmation notification for. If set to a hash of all zeros, then the confirmation notification will be requested for the script instead.	bytes	string	body
script An output script within a transaction with the hash above which will be used by light clients to match block filters. If the transaction hash is set to a hash of all zeros, then a confirmation notification will be requested for this script instead.	bytes	string	body
num_confs The number of desired confirmations the transaction/output script should reach before dispatching a confirmation notification.	uint32	integer	body
height_hint The earliest height in the chain for which the transaction/output script could have been included in a block. This should in most cases be set to the broadcast height of the transaction/output script.	uint32	integer	body
include_block If true, then the block that mines the specified txid/script will be included in eventual the notification event.	bool	boolean	body

chainrpc.ConfEvent

Source: chainrpc/chainnotifier.proto

Field	gRPC Type	REST Type
conf An event that includes the confirmation details of the request (txid/ouput script).	ConfDetails	object
reorg An event send when the transaction of the request is reorged out of the chain.	Reorg	object

Nested Messages

chainrpc.ConfDetails

Field	gRPC Type	REST Type
raw_tx The raw bytes of the confirmed transaction.	bytes	string
block_hash The hash of the block in which the confirmed transaction was included in.	bytes	string
block_height The height of the block in which the confirmed transaction was included in.	uint32	integer
tx_index The index of the confirmed transaction within the block.	uint32	integer
raw_block The raw bytes of the block that mined the transaction. Only included if include_block was set in the request.	bytes	string

chainrpc.Reorg

note

This response has no parameters.