SignCoordinatorStreams

SignCoordinatorStreams dispatches a bi-directional streaming RPC that allows a remote signer to connect to a watch-only node and remotely provide signatures and ECDH results on demand.

Source: watchonlyrpc/watchonly.proto

gRPC

info

This is a bidirectional-streaming RPC

rpc SignCoordinatorStreams (stream SignCoordinatorResponse) returns (stream SignCoordinatorRequest);

REST

HTTP Method	Path
POST	/v2/watchonly/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', 'watchonlyrpc/watchonly.proto'], loaderOptions);
const watchonlyrpc = grpc.loadPackageDefinition(packageDefinition).watchonlyrpc;
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 watchonlyrpc.WatchOnly(GRPC_HOST, creds);
let request = {
  ref_request_id: <uint64>,
  signer_registration: <SignerRegistration>,
  pong: <bool>,
  shared_key_response: <SharedKeyResponse>,
  sign_message_resp: <SignMessageResp>,
  mu_sig2_session_response: <MuSig2SessionResponse>,
  mu_sig2_register_nonces_response: <MuSig2RegisterNoncesResponse>,
  mu_sig2_comb_nonces_resp: <MuSig2RegisterCombinedNonceResponse>,
  mu_sig2_get_comb_nonces_resp: <MuSig2GetCombinedNonceResponse>,
  mu_sig2_sign_response: <MuSig2SignResponse>,
  mu_sig2_combine_sig_response: <MuSig2CombineSigResponse>,
  mu_sig2_cleanup_response: <MuSig2CleanupResponse>,
  sign_psbt_response: <SignPsbtResponse>,
  signer_error: <SignerError>,
};
let call = client.signCoordinatorStreams({});
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.
});
call.write(request);
// Console output:
//  {
//    "request_id": <uint64>,
//    "registration_response": <RegistrationResponse>,
//    "ping": <bool>,
//    "shared_key_request": <SharedKeyRequest>,
//    "sign_message_req": <SignMessageReq>,
//    "mu_sig2_session_request": <MuSig2SessionRequest>,
//    "mu_sig2_register_nonces_request": <MuSig2RegisterNoncesRequest>,
//    "mu_sig2_combined_nonces_req": <MuSig2RegisterCombinedNonceRequest>,
//    "mu_sig2_get_combined_nonces_req": <MuSig2GetCombinedNonceRequest>,
//    "mu_sig2_sign_request": <MuSig2SignRequest>,
//    "mu_sig2_combine_sig_request": <MuSig2CombineSigRequest>,
//    "mu_sig2_cleanup_request": <MuSig2CleanupRequest>,
//    "sign_psbt_request": <SignPsbtRequest>,
//  }

Python

import codecs, grpc, os
# Generate the following 2 modules by compiling the watchonlyrpc/watchonly.proto with the grpcio-tools.
# See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
import watchonly_pb2 as watchonlyrpc, watchonly_pb2_grpc as watchonlystub

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 = watchonlystub.WatchOnlyStub(channel)
# Define a generator that returns an Iterable of SignCoordinatorResponse objects.
def request_generator():
    # Initialization code here.
    while True:
        # Parameters here can be set as arguments to the generator.
        request = watchonlyrpc.SignCoordinatorResponse(
            ref_request_id=<uint64>,
            signer_registration=<SignerRegistration>,
            pong=<bool>,
            shared_key_response=<SharedKeyResponse>,
            sign_message_resp=<SignMessageResp>,
            mu_sig2_session_response=<MuSig2SessionResponse>,
            mu_sig2_register_nonces_response=<MuSig2RegisterNoncesResponse>,
            mu_sig2_comb_nonces_resp=<MuSig2RegisterCombinedNonceResponse>,
            mu_sig2_get_comb_nonces_resp=<MuSig2GetCombinedNonceResponse>,
            mu_sig2_sign_response=<MuSig2SignResponse>,
            mu_sig2_combine_sig_response=<MuSig2CombineSigResponse>,
            mu_sig2_cleanup_response=<MuSig2CleanupResponse>,
            sign_psbt_response=<SignPsbtResponse>,
            signer_error=<SignerError>,
        )
        yield request
        # Do things between iterations here.
request_iterable = request_generator()
for response in stub.SignCoordinatorStreams(request_iterable):
  print(response)
# {
#    "request_id": <uint64>,
#    "registration_response": <RegistrationResponse>,
#    "ping": <bool>,
#    "shared_key_request": <SharedKeyRequest>,
#    "sign_message_req": <SignMessageReq>,
#    "mu_sig2_session_request": <MuSig2SessionRequest>,
#    "mu_sig2_register_nonces_request": <MuSig2RegisterNoncesRequest>,
#    "mu_sig2_combined_nonces_req": <MuSig2RegisterCombinedNonceRequest>,
#    "mu_sig2_get_combined_nonces_req": <MuSig2GetCombinedNonceRequest>,
#    "mu_sig2_sign_request": <MuSig2SignRequest>,
#    "mu_sig2_combine_sig_request": <MuSig2CombineSigRequest>,
#    "mu_sig2_cleanup_request": <MuSig2CleanupRequest>,
#    "sign_psbt_request": <SignPsbtRequest>,
# }

grpcurl

# grpcurl docs: https://github.com/fullstorydev/grpcurl
# Proto source: https://github.com/lightningnetwork/lnd
GRPC_HOST=localhost:10009
LND_DIR=~/.lnd
LND_SOURCE=path/to/lnd
NETWORK=mainnet
MACAROON_PATH="$LND_DIR/data/chain/bitcoin/$NETWORK/admin.macaroon"
TLS_PATH="$LND_DIR/tls.cert"

# Client streaming or bidirectional streaming RPCs are not easily supported
# by grpcurl. Please use a programming language client for this RPC.

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 = {
  ref_request_id: <string>, // <uint64> 
  signer_registration: <object>, // <SignerRegistration> 
  pong: <boolean>, // <bool> 
  shared_key_response: <object>, // <SharedKeyResponse> 
  sign_message_resp: <object>, // <SignMessageResp> 
  mu_sig2_session_response: <object>, // <MuSig2SessionResponse> 
  mu_sig2_register_nonces_response: <object>, // <MuSig2RegisterNoncesResponse> 
  mu_sig2_comb_nonces_resp: <object>, // <MuSig2RegisterCombinedNonceResponse> 
  mu_sig2_get_comb_nonces_resp: <object>, // <MuSig2GetCombinedNonceResponse> 
  mu_sig2_sign_response: <object>, // <MuSig2SignResponse> 
  mu_sig2_combine_sig_response: <object>, // <MuSig2CombineSigResponse> 
  mu_sig2_cleanup_response: <object>, // <MuSig2CleanupResponse> 
  sign_psbt_response: <object>, // <SignPsbtResponse> 
  signer_error: <object>, // <SignerError> 
};
let options = {
  url: `https://${REST_HOST}/v2/watchonly/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:
//  {
//    "request_id": <string>, // <uint64> 
//    "registration_response": <object>, // <RegistrationResponse> 
//    "ping": <boolean>, // <bool> 
//    "shared_key_request": <object>, // <SharedKeyRequest> 
//    "sign_message_req": <object>, // <SignMessageReq> 
//    "mu_sig2_session_request": <object>, // <MuSig2SessionRequest> 
//    "mu_sig2_register_nonces_request": <object>, // <MuSig2RegisterNoncesRequest> 
//    "mu_sig2_combined_nonces_req": <object>, // <MuSig2RegisterCombinedNonceRequest> 
//    "mu_sig2_get_combined_nonces_req": <object>, // <MuSig2GetCombinedNonceRequest> 
//    "mu_sig2_sign_request": <object>, // <MuSig2SignRequest> 
//    "mu_sig2_combine_sig_request": <object>, // <MuSig2CombineSigRequest> 
//    "mu_sig2_cleanup_request": <object>, // <MuSig2CleanupRequest> 
//    "sign_psbt_request": <object>, // <SignPsbtRequest> 
//  }



// --------------------------
// 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/watchonly/stream?method=POST`, {
  // Work-around for self-signed certificates.
  rejectUnauthorized: false,
  headers: {
    'Grpc-Metadata-Macaroon': fs.readFileSync(MACAROON_PATH).toString('hex'),
  },
});
let requestBody = {
  ref_request_id: <uint64>, // <uint64> 
  signer_registration: <SignerRegistration>, // <SignerRegistration> 
  pong: <bool>, // <bool> 
  shared_key_response: <SharedKeyResponse>, // <SharedKeyResponse> 
  sign_message_resp: <SignMessageResp>, // <SignMessageResp> 
  mu_sig2_session_response: <MuSig2SessionResponse>, // <MuSig2SessionResponse> 
  mu_sig2_register_nonces_response: <MuSig2RegisterNoncesResponse>, // <MuSig2RegisterNoncesResponse> 
  mu_sig2_comb_nonces_resp: <MuSig2RegisterCombinedNonceResponse>, // <MuSig2RegisterCombinedNonceResponse> 
  mu_sig2_get_comb_nonces_resp: <MuSig2GetCombinedNonceResponse>, // <MuSig2GetCombinedNonceResponse> 
  mu_sig2_sign_response: <MuSig2SignResponse>, // <MuSig2SignResponse> 
  mu_sig2_combine_sig_response: <MuSig2CombineSigResponse>, // <MuSig2CombineSigResponse> 
  mu_sig2_cleanup_response: <MuSig2CleanupResponse>, // <MuSig2CleanupResponse> 
  sign_psbt_response: <SignPsbtResponse>, // <SignPsbtResponse> 
  signer_error: <SignerError>, // <SignerError> 
};
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:
//  {
//    "request_id": <string>, // <uint64>
//    "registration_response": <object>, // <RegistrationResponse>
//    "ping": <boolean>, // <bool>
//    "shared_key_request": <object>, // <SharedKeyRequest>
//    "sign_message_req": <object>, // <SignMessageReq>
//    "mu_sig2_session_request": <object>, // <MuSig2SessionRequest>
//    "mu_sig2_register_nonces_request": <object>, // <MuSig2RegisterNoncesRequest>
//    "mu_sig2_combined_nonces_req": <object>, // <MuSig2RegisterCombinedNonceRequest>
//    "mu_sig2_get_combined_nonces_req": <object>, // <MuSig2GetCombinedNonceRequest>
//    "mu_sig2_sign_request": <object>, // <MuSig2SignRequest>
//    "mu_sig2_combine_sig_request": <object>, // <MuSig2CombineSigRequest>
//    "mu_sig2_cleanup_request": <object>, // <MuSig2CleanupRequest>
//    "sign_psbt_request": <object>, // <SignPsbtRequest>
//  }

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/watchonly/stream'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
data = {
  'ref_request_id': <uint64>,
  'signer_registration': <SignerRegistration>,
  'pong': <bool>,
  'shared_key_response': <SharedKeyResponse>,
  'sign_message_resp': <SignMessageResp>,
  'mu_sig2_session_response': <MuSig2SessionResponse>,
  'mu_sig2_register_nonces_response': <MuSig2RegisterNoncesResponse>,
  'mu_sig2_comb_nonces_resp': <MuSig2RegisterCombinedNonceResponse>,
  'mu_sig2_get_comb_nonces_resp': <MuSig2GetCombinedNonceResponse>,
  'mu_sig2_sign_response': <MuSig2SignResponse>,
  'mu_sig2_combine_sig_response': <MuSig2CombineSigResponse>,
  'mu_sig2_cleanup_response': <MuSig2CleanupResponse>,
  'sign_psbt_response': <SignPsbtResponse>,
  'signer_error': <SignerError>,
}
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)
# {
#    "request_id": <uint64>,
#    "registration_response": <RegistrationResponse>,
#    "ping": <bool>,
#    "shared_key_request": <SharedKeyRequest>,
#    "sign_message_req": <SignMessageReq>,
#    "mu_sig2_session_request": <MuSig2SessionRequest>,
#    "mu_sig2_register_nonces_request": <MuSig2RegisterNoncesRequest>,
#    "mu_sig2_combined_nonces_req": <MuSig2RegisterCombinedNonceRequest>,
#    "mu_sig2_get_combined_nonces_req": <MuSig2GetCombinedNonceRequest>,
#    "mu_sig2_sign_request": <MuSig2SignRequest>,
#    "mu_sig2_combine_sig_request": <MuSig2CombineSigRequest>,
#    "mu_sig2_cleanup_request": <MuSig2CleanupRequest>,
#    "sign_psbt_request": <SignPsbtRequest>,
# }

curl

REST_HOST=localhost:8080
LND_DIR=~/.lnd
NETWORK=mainnet
MACAROON_PATH="$LND_DIR/data/chain/bitcoin/$NETWORK/admin.macaroon"
TLS_PATH="$LND_DIR/tls.cert"

curl -X POST \
    --cacert $TLS_PATH \
    -H "Grpc-Metadata-macaroon: $(xxd -ps -u -c 1000 $MACAROON_PATH)" \
    -d '{ "ref_request_id": <uint64>, "signer_registration": <SignerRegistration>, "pong": <bool>, "shared_key_response": <SharedKeyResponse>, "sign_message_resp": <SignMessageResp>, "mu_sig2_session_response": <MuSig2SessionResponse>, "mu_sig2_register_nonces_response": <MuSig2RegisterNoncesResponse>, "mu_sig2_comb_nonces_resp": <MuSig2RegisterCombinedNonceResponse>, "mu_sig2_get_comb_nonces_resp": <MuSig2GetCombinedNonceResponse>, "mu_sig2_sign_response": <MuSig2SignResponse>, "mu_sig2_combine_sig_response": <MuSig2CombineSigResponse>, "mu_sig2_cleanup_response": <MuSig2CleanupResponse>, "sign_psbt_response": <SignPsbtResponse>, "signer_error": <SignerError> }' \
    https://$REST_HOST/v2/watchonly/stream

Messages

watchonlyrpc.SignCoordinatorResponse

Source: watchonlyrpc/watchonly.proto

Field	gRPC Type	REST Type	REST Placement
ref_request_id The request ID this response refers to.	uint64	string	body
signer_registration The Signer Registration message is sent by the remote signer when it connects to the watch-only lnd node, to initialize a handshake between the nodes.	SignerRegistration	object	body
pong To ensure that the remote signer is still active and alive, the watch-only node can send a Ping message to remote signer. This Pong message should then be sent by the remote signer to respond to the Ping message.	bool	boolean	body
shared_key_response The remote signer's corresponding response to a Shared Key request.	SharedKeyResponse	object	body
sign_message_resp The remote signer's corresponding response to a Sign Message request.	SignMessageResp	object	body
mu_sig2_session_response The remote signer's corresponding response to a Mu Sig2 Session request.	MuSig2SessionResponse	object	body
mu_sig2_register_nonces_response The remote signer's corresponding response to a Mu Sig2 Register Nonces request.	MuSig2RegisterNoncesResponse	object	body
mu_sig2_comb_nonces_resp The remote signer's corresponding response to a Mu Sig2 Register Combined Nonces request.	MuSig2RegisterCombinedNonceResponse	object	body
mu_sig2_get_comb_nonces_resp The remote signer's corresponding response to a Mu Sig2 Get Combined Nonces request.	MuSig2GetCombinedNonceResponse	object	body
mu_sig2_sign_response The remote signer's corresponding response to a Mu Sig2 Sign request.	MuSig2SignResponse	object	body
mu_sig2_combine_sig_response The remote signer's corresponding response to a Mu Sig2 Combine Sig request.	MuSig2CombineSigResponse	object	body
mu_sig2_cleanup_response The remote signer's corresponding response to a Mu Sig2 Cleanup request.	MuSig2CleanupResponse	object	body
sign_psbt_response The remote signer's corresponding response to a Sign Psbt request.	SignPsbtResponse	object	body
signer_error If the remote signer encounters an error while processing a request, it will respond with a SignerError message that details the error.	SignerError	object	body

watchonlyrpc.SignCoordinatorRequest

Source: watchonlyrpc/watchonly.proto

Field	gRPC Type	REST Type
request_id A unique request ID of a SignCoordinator gRPC request. Useful for mapping requests to responses. Note that request_id 1 is reserved for the handshake with between watch-only node and the remote signer.	uint64	string
registration_response The Registration Response message is returned by the watch-only lnd as a response to SignerRegistration message.	RegistrationResponse	object
ping To ensure that the remote signer is still active and alive, the watch-only lnd can send a Ping message to the remote signer, which should then respond with the respective Pong message.	bool	boolean
shared_key_request Requests a shared public key from the remote signer.	SharedKeyRequest	object
sign_message_req Requests that the remote signer signs the passed message.	SignMessageReq	object
mu_sig2_session_request Requests a MuSig2 Session of the remote signer.	MuSig2SessionRequest	object
mu_sig2_register_nonces_request Requests that the remote signer registers a nonce with the referenced MuSig2 Session.	MuSig2RegisterNoncesRequest	object
mu_sig2_combined_nonces_req Requests that the remote signer registers a combined nonce with the referenced MuSig2 Session.	MuSig2RegisterCombinedNonceRequest	object
mu_sig2_get_combined_nonces_req Requests that the remote signer gets a combined nonce with the referenced MuSig2 Session.	MuSig2GetCombinedNonceRequest	object
mu_sig2_sign_request Requests that the remote signer signs the passed message digest with the referenced MuSig2 Session.	MuSig2SignRequest	object
mu_sig2_combine_sig_request Requests that the remote signer combines and adds the passed partial signatures for the referenced MuSig2 Session.	MuSig2CombineSigRequest	object
mu_sig2_cleanup_request Requests that the remote signer removes/cleans up the referenced MuSig2 session.	MuSig2CleanupRequest	object
sign_psbt_request Requests that the remote signer signs the passed PSBT.	SignPsbtRequest	object

Nested Messages

signrpc.KeyDescriptor

Field	gRPC Type	REST Type
raw_key_bytes The raw bytes of the public key in the key pair being identified. Either this or the KeyLocator must be specified.	bytes	string
key_loc The key locator that identifies which private key to use for signing. Either this or the raw bytes of the target public key must be specified.	KeyLocator	object

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

signrpc.MuSig2CleanupRequest

Field	gRPC Type	REST Type
session_id The unique ID of the signing session that should be removed/cleaned up.	bytes	string

signrpc.MuSig2CleanupResponse

note

This response has no parameters.

signrpc.MuSig2CombineSigRequest

Field	gRPC Type	REST Type
session_id The unique ID of the signing session to combine the signatures for.	bytes	string
other_partial_signatures The list of all other participants' partial signatures to add to the current session.	bytes[]	array

signrpc.MuSig2CombineSigResponse

Field	gRPC Type	REST Type
have_all_signatures Indicates whether all partial signatures required to create a final, full signature are known yet. If this is true, then the final_signature field is set, otherwise it is empty.	bool	boolean
final_signature The final, full signature that is valid for the combined public key.	bytes	string

signrpc.MuSig2GetCombinedNonceRequest

Field	gRPC Type	REST Type
session_id The unique ID of the signing session to get the combined nonce for.	bytes	string

signrpc.MuSig2GetCombinedNonceResponse

Field	gRPC Type	REST Type
combined_public_nonce The 66-byte combined public nonce. This is a concatenation of two 33-byte compressed public keys (R1 || R2).	bytes	string

signrpc.MuSig2RegisterCombinedNonceRequest

Field	gRPC Type	REST Type
session_id The unique ID of the signing session the combined nonce should be registered with.	bytes	string
combined_public_nonce The 66-byte combined public nonce that was aggregated externally. This is a concatenation of two 33-byte compressed public keys (R1 || R2).	bytes	string

signrpc.MuSig2RegisterCombinedNonceResponse

note

This response has no parameters.

signrpc.MuSig2RegisterNoncesRequest

Field	gRPC Type	REST Type
session_id The unique ID of the signing session those nonces should be registered with.	bytes	string
other_signer_public_nonces A list of all public nonces of other signing participants that should be registered.	bytes[]	array

signrpc.MuSig2RegisterNoncesResponse

Field	gRPC Type	REST Type
have_all_nonces Indicates whether all nonces required to start the signing process are known now.	bool	boolean

signrpc.MuSig2SessionRequest

Field	gRPC Type	REST Type
key_loc The key locator that identifies which key to use for signing.	KeyLocator	object
all_signer_pubkeys A list of all public keys (serialized in 32-byte x-only format for v0.4.0 and 33-byte compressed format for v1.0.0rc2!) participating in the signing session. The list will always be sorted lexicographically internally. This must include the local key which is described by the above key_loc.	bytes[]	array
other_signer_public_nonces An optional list of all public nonces of other signing participants that might already be known.	bytes[]	array
tweaks A series of optional generic tweaks to be applied to the aggregated public key.	TweakDesc[]	array
taproot_tweak An optional taproot specific tweak that must be specified if the MuSig2 combined key will be used as the main taproot key of a taproot output on-chain.	TaprootTweakDesc	object
version The mandatory version of the MuSig2 BIP draft to use. This is necessary to differentiate between the changes that were made to the BIP while this experimental RPC was already released. Some of those changes affect how the combined key and nonces are created.	MuSig2Version	string
pregenerated_local_nonce A set of pre generated secret local nonces to use in the musig2 session. This field is optional. This can be useful for protocols that need to send nonces ahead of time before the set of signer keys are known. This value MUST be 97 bytes and be the concatenation of two CSPRNG generated 32 byte values and local public key used for signing as specified in the key_loc field.	bytes	string

signrpc.MuSig2SessionResponse

Field	gRPC Type	REST Type
session_id The unique ID that represents this signing session. A session can be used for producing a signature a single time. If the signing fails for any reason, a new session with the same participants needs to be created.	bytes	string
combined_key The combined public key (in the 32-byte x-only format) with all tweaks applied to it. If a taproot tweak is specified, this corresponds to the taproot key that can be put into the on-chain output.	bytes	string
taproot_internal_key The raw combined public key (in the 32-byte x-only format) before any tweaks are applied to it. If a taproot tweak is specified, this corresponds to the internal key that needs to be put into the witness if the script spend path is used.	bytes	string
local_public_nonces The two public nonces the local signer uses, combined into a single value of 66 bytes. Can be split into the two 33-byte points to get the individual nonces.	bytes	string
have_all_nonces Indicates whether all nonces required to start the signing process are known now.	bool	boolean
version The version of the MuSig2 BIP that was used to create the session.	MuSig2Version	string

signrpc.MuSig2SignRequest

Field	gRPC Type	REST Type
session_id The unique ID of the signing session to use for signing.	bytes	string
message_digest The 32-byte SHA256 digest of the message to sign.	bytes	string
cleanup Cleanup indicates that after signing, the session state can be cleaned up, since another participant is going to be responsible for combining the partial signatures.	bool	boolean

signrpc.MuSig2SignResponse

Field	gRPC Type	REST Type
local_partial_signature The partial signature created by the local signer.	bytes	string

signrpc.SharedKeyRequest

Field	gRPC Type	REST Type
ephemeral_pubkey The ephemeral public key to use for the DH key derivation.	bytes	string
key_locdeprecated Deprecated. The optional key locator of the local key that should be used. If this parameter is not set then the node's identity private key will be used.	KeyLocator	object
key_desc A key descriptor describes the key used for performing ECDH. Either a key locator or a raw public key is expected, if neither is supplied, defaults to the node's identity private key.	KeyDescriptor	object

signrpc.SharedKeyResponse

Field	gRPC Type	REST Type
shared_key The shared public key, hashed with sha256.	bytes	string

signrpc.SignMessageReq

Field	gRPC Type	REST Type
msg The message to be signed. When using REST, this field must be encoded as base64.	bytes	string
key_loc The key locator that identifies which key to use for signing.	KeyLocator	object
double_hash Double-SHA256 hash instead of just the default single round.	bool	boolean
compact_sig Use the compact (pubkey recoverable) format instead of the raw lnwire format. This option cannot be used with Schnorr signatures.	bool	boolean
schnorr_sig Use Schnorr signature. This option cannot be used with compact format.	bool	boolean
schnorr_sig_tap_tweak The optional Taproot tweak bytes to apply to the private key before creating a Schnorr signature. The private key is tweaked as described in BIP-341: privKey + h_tapTweak(internalKey || tapTweak)	bytes	string
tag An optional tag that can be provided when taking a tagged hash of a message. This option can only be used when schnorr_sig is true.	bytes	string

signrpc.SignMessageResp

Field	gRPC Type	REST Type
signature The signature for the given message in the fixed-size LN wire format.	bytes	string

signrpc.TaprootTweakDesc

Field	gRPC Type	REST Type
script_root The root hash of the tapscript tree if a script path is committed to. If the MuSig2 key put on chain doesn't also commit to a script path (BIP-0086 key spend only), then this needs to be empty and the key_spend_only field below must be set to true. This is required because gRPC cannot differentiate between a zero-size byte slice and a nil byte slice (both would be serialized the same way). So the extra boolean is required.	bytes	string
key_spend_only Indicates that the above script_root is expected to be empty because this is a BIP-0086 key spend only commitment where only the internal key is committed to instead of also including a script root hash.	bool	boolean

signrpc.TweakDesc

Field	gRPC Type	REST Type
tweak Tweak is the 32-byte value that will modify the public key.	bytes	string
is_x_only Specifies if the target key should be converted to an x-only public key before tweaking. If true, then the public key will be mapped to an x-only key before the tweaking operation is applied.	bool	boolean

walletrpc.SignPsbtRequest

Field	gRPC Type	REST Type
funded_psbt The PSBT that should be signed. The PSBT must contain all required inputs, outputs, UTXO data and custom fields required to identify the signing key.	bytes	string

walletrpc.SignPsbtResponse

Field	gRPC Type	REST Type
signed_psbt The signed transaction in PSBT format.	bytes	string
signed_inputs The indices of signed inputs.	uint32[]	array

watchonlyrpc.RegistrationComplete

Field	gRPC Type	REST Type
signature Holds the signature generated by the watch-only node when signing the registration_challenge provided by the remote signer in SignerRegistration.	string	string
registration_info Contains information about the watch-only lnd that may be useful for the remote signer.	string	string

watchonlyrpc.RegistrationResponse

Field	gRPC Type	REST Type
registration_complete Sent by the watch-only lnd when the remote signer registration is successful.	RegistrationComplete	object
registration_error Contains details about any errors that occurred during remote signer registration.	string	string

watchonlyrpc.SignerError

Field	gRPC Type	REST Type
error Details an error which occurred on remote signer.	string	string

watchonlyrpc.SignerRegistration

Field	gRPC Type	REST Type
registration_challenge The registration challenge allows the remote signer to pass data that will be signed by the watch-only lnd. The resulting signature will be returned in the RegistrationResponse message.	bytes	string
registration_info The registration info contains details about the remote signer that may be useful for the watch-only lnd.	string	string

Enums

signrpc.MuSig2Version

Name	Number
MUSIG2_VERSION_UNDEFINED The default value on the RPC is zero for enums so we need to represent an invalid/undefined version by default to make sure clients upgrade their software to set the version explicitly.	0
MUSIG2_VERSION_V040 The version of MuSig2 that lnd 0.15.x shipped with, which corresponds to the version v0.4.0 of the MuSig2 BIP draft.	1
MUSIG2_VERSION_V100RC2 The current version of MuSig2 which corresponds to the version v1.0.0rc2 of the MuSig2 BIP draft.	2