VerifyChanBackup

VerifyChanBackup allows a caller to verify the integrity of a channel backup snapshot. This method will accept either a packed Single or a packed Multi. Specifying both will result in an error.

Source: lightning.proto

gRPC

rpc VerifyChanBackup (ChanBackupSnapshot) returns (VerifyChanBackupResponse);

REST

HTTP Method	Path
POST	/v1/channels/backup/verify

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 = {
  single_chan_backups: <ChannelBackups>,
  multi_chan_backup: <MultiChanBackup>,
};
client.verifyChanBackup(request, function(err, response) {
  console.log(response);
});
// Console output:
//  {
//    "chan_points": <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.ChanBackupSnapshot(
  single_chan_backups=<ChannelBackups>,
  multi_chan_backup=<MultiChanBackup>,
)
response = stub.VerifyChanBackup(request)
print(response)
# {
#    "chan_points": <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 = {
  single_chan_backups: <object>, // <ChannelBackups> 
  multi_chan_backup: <object>, // <MultiChanBackup> 
};
let options = {
  url: `https://${REST_HOST}/v1/channels/backup/verify`,
  // 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_points": <array>, // <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/channels/backup/verify'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
data = {
  'single_chan_backups': <ChannelBackups>,
  'multi_chan_backup': <MultiChanBackup>,
}
r = requests.post(url, headers=headers, data=json.dumps(data), verify=TLS_PATH)
print(r.json())
# {
#    "chan_points": <string>,
# }

Shell

$ lncli verifychanbackup --help

NAME:
   lncli verifychanbackup - Verify an existing channel backup.

USAGE:
   lncli verifychanbackup [command options] [--single_backup] [--multi_backup] [--multi_file]

CATEGORY:
   Channels

DESCRIPTION:
   
    This command allows a user to verify an existing Single or Multi channel
    backup for integrity. This is useful when a user has a backup, but is
    unsure as to if it's valid or for the target node.

    The command will accept backups in one of four forms:

       * A single channel packed SCB, which can be obtained from
   exportchanbackup. This should be passed in hex encoded format.

       * A packed multi-channel SCB, which couples several individual
   static channel backups in single blob.

       * A file path which points to a packed single-channel backup within a
         file, using the same format that lnd does in its channel.backup file.

       * A file path which points to a packed multi-channel backup within a
   file, using the same format that lnd does in its channel.backup
   file.
    

OPTIONS:
   --single_backup value  a hex encoded single channel backup obtained from exportchanbackup
   --multi_backup value   a hex encoded multi-channel backup obtained from exportchanbackup
   --single_file value    the path to a single-channel backup file
   --multi_file value     the path to a multi-channel back up file
   

Messages

lnrpc.ChanBackupSnapshot

Source: lightning.proto

Field	gRPC Type	REST Type	REST Placement
single_chan_backups The set of new channels that have been added since the last channel backup snapshot was requested.	ChannelBackups	object	body
multi_chan_backup A multi-channel backup that covers all open channels currently known to lnd.	MultiChanBackup	object	body

lnrpc.VerifyChanBackupResponse

Source: lightning.proto

Field	gRPC Type	REST Type
chan_points	string[]	array

Nested Messages

lnrpc.ChannelBackup

Field	gRPC Type	REST Type
chan_point Identifies the channel that this backup belongs to.	ChannelPoint	object
chan_backup Is an encrypted single-chan backup. this can be passed to RestoreChannelBackups, or the WalletUnlocker Init and Unlock methods in order to trigger the recovery protocol. When using REST, this field must be encoded as base64.	bytes	string

lnrpc.ChannelBackups

Field	gRPC Type	REST Type
chan_backups A set of single-chan static channel backups.	ChannelBackup[]	array

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.MultiChanBackup

Field	gRPC Type	REST Type
chan_points Is the set of all channels that are included in this multi-channel backup.	ChannelPoint[]	array
multi_chan_backup A single encrypted blob containing all the static channel backups of the channel listed above. This can be stored as a single file or blob, and safely be replaced with any prior/future versions. When using REST, this field must be encoded as base64.	bytes	string