VerifyMessage

VerifyMessage verifies a signature over a message using the public key provided. The signature must be fixed-size LN wire format encoded.

The main difference to VerifyMessage in the main RPC is that the public key used to sign the message does not have to be a node known to the network.

Source: signrpc/signer.proto

gRPC

rpc VerifyMessage (VerifyMessageReq) returns (VerifyMessageResp);

REST

HTTP Method	Path
POST	/v2/signer/verifymessage

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', 'signrpc/signer.proto'], loaderOptions);
const signrpc = grpc.loadPackageDefinition(packageDefinition).signrpc;
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 signrpc.Signer(GRPC_HOST, creds);
let request = {
  msg: <bytes>,
  signature: <bytes>,
  pubkey: <bytes>,
  is_schnorr_sig: <bool>,
  tag: <bytes>,
};
client.verifyMessage(request, function(err, response) {
  console.log(response);
});
// Console output:
//  {
//    "valid": <bool>,
//  }

Python

import codecs, grpc, os
# Generate the following 2 modules by compiling the signrpc/signer.proto with the grpcio-tools.
# See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
import signer_pb2 as signrpc, signer_pb2_grpc as signerstub

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 = signerstub.SignerStub(channel)
request = signrpc.VerifyMessageReq(
  msg=<bytes>,
  signature=<bytes>,
  pubkey=<bytes>,
  is_schnorr_sig=<bool>,
  tag=<bytes>,
)
response = stub.VerifyMessage(request)
print(response)
# {
#    "valid": <bool>,
# }

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 = {
  msg: <string>, // <bytes> (base64 encoded)
  signature: <string>, // <bytes> (base64 encoded)
  pubkey: <string>, // <bytes> (base64 encoded)
  is_schnorr_sig: <boolean>, // <bool> 
  tag: <string>, // <bytes> (base64 encoded)
};
let options = {
  url: `https://${REST_HOST}/v2/signer/verifymessage`,
  // 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:
//  {
//    "valid": <boolean>, // <bool> 
//  }

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/signer/verifymessage'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
data = {
  'msg': base64.b64encode(<bytes>),
  'signature': base64.b64encode(<bytes>),
  'pubkey': base64.b64encode(<bytes>),
  'is_schnorr_sig': <bool>,
  'tag': base64.b64encode(<bytes>),
}
r = requests.post(url, headers=headers, data=json.dumps(data), verify=TLS_PATH)
print(r.json())
# {
#    "valid": <bool>,
# }

Shell

# There is no CLI command for this RPC

Messages

signrpc.VerifyMessageReq

Source: signrpc/signer.proto

Field	gRPC Type	REST Type	REST Placement
msg The message over which the signature is to be verified. When using REST, this field must be encoded as base64.	bytes	string	body
signature The fixed-size LN wire encoded signature to be verified over the given message. When using REST, this field must be encoded as base64.	bytes	string	body
pubkey The public key the signature has to be valid for. When using REST, this field must be encoded as base64. If the is_schnorr_sig option is true, then the public key is expected to be in the 32-byte x-only serialization according to BIP-340.	bytes	string	body
is_schnorr_sig Specifies if the signature is a Schnorr signature.	bool	boolean	body
tag An optional tag that can be provided when taking a tagged hash of a message. This option can only be used when is_schnorr_sig is true.	bytes	string	body

signrpc.VerifyMessageResp

Source: signrpc/signer.proto

Field	gRPC Type	REST Type
valid Whether the signature was valid over the given message.	bool	boolean