SubscribeOnionMessages

SubscribeOnionMessages subscribes to a stream of incoming onion messages.

Source: lightning.proto

gRPC

info

This is a server-streaming RPC

rpc SubscribeOnionMessages (SubscribeOnionMessagesRequest) returns (stream OnionMessageUpdate);

REST

HTTP Method	Path
GET	/v1/onionmessage/subscribe

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 = {};
let call = client.subscribeOnionMessages(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:
//  {
//    "peer": <bytes>,
//    "path_key": <bytes>,
//    "onion": <bytes>,
//    "reply_path": <BlindedPath>,
//    "encrypted_recipient_data": <bytes>,
//    "custom_records": <CustomRecordsEntry>,
//  }

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.SubscribeOnionMessagesRequest()
for response in stub.SubscribeOnionMessages(request):
  print(response)
# {
#    "peer": <bytes>,
#    "path_key": <bytes>,
#    "onion": <bytes>,
#    "reply_path": <BlindedPath>,
#    "encrypted_recipient_data": <bytes>,
#    "custom_records": <CustomRecordsEntry>,
# }

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"

grpcurl \
    -import-path $LND_SOURCE/lnrpc/ \
    -proto lightning.proto \
    -cacert $TLS_PATH \
    -H "macaroon: $(xxd -ps -u -c 1000 $MACAROON_PATH)" \
    $GRPC_HOST \
    lnrpc.Lightning/SubscribeOnionMessages

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 options = {
  url: `https://${REST_HOST}/v1/onionmessage/subscribe`,
  // Work-around for self-signed certificates.
  rejectUnauthorized: false,
  json: true,
  headers: {
    'Grpc-Metadata-macaroon': fs.readFileSync(MACAROON_PATH).toString('hex'),
  },
}
request.get(options, function(error, response, body) {
  console.log(body);
});
// Console output:
//  {
//    "peer": <string>, // <bytes> 
//    "path_key": <string>, // <bytes> 
//    "onion": <string>, // <bytes> 
//    "reply_path": <object>, // <BlindedPath> 
//    "encrypted_recipient_data": <string>, // <bytes> 
//    "custom_records": <object>, // <CustomRecordsEntry> 
//  }



// --------------------------
// 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/onionmessage/subscribe?method=GET`, {
  // Work-around for self-signed certificates.
  rejectUnauthorized: false,
  headers: {
    'Grpc-Metadata-Macaroon': fs.readFileSync(MACAROON_PATH).toString('hex'),
  },
});
let requestBody = {
};
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:
//  {
//    "peer": <string>, // <bytes>
//    "path_key": <string>, // <bytes>
//    "onion": <string>, // <bytes>
//    "reply_path": <object>, // <BlindedPath>
//    "encrypted_recipient_data": <string>, // <bytes>
//    "custom_records": <object>, // <CustomRecordsEntry>
//  }

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/onionmessage/subscribe'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
r = requests.get(url, headers=headers, stream=True, verify=TLS_PATH)
for raw_response in r.iter_lines():
  json_response = json.loads(raw_response)
  print(json_response)
# {
#    "peer": <bytes>,
#    "path_key": <bytes>,
#    "onion": <bytes>,
#    "reply_path": <BlindedPath>,
#    "encrypted_recipient_data": <bytes>,
#    "custom_records": <CustomRecordsEntry>,
# }

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 \
    --cacert $TLS_PATH \
    -H "Grpc-Metadata-macaroon: $(xxd -ps -u -c 1000 $MACAROON_PATH)" \
    https://$REST_HOST/v1/onionmessage/subscribe

Messages

lnrpc.SubscribeOnionMessagesRequest

Source: lightning.proto

note

This request has no parameters.

lnrpc.OnionMessageUpdate

Source: lightning.proto

Field	gRPC Type	REST Type
peer Peer from which this message originates. Represented as a byte-encoded public key.	bytes	string
path_key PathKey is used to derive the blinded node id by tweaking the hop's static public key. The hop uses the corresponding blinded private key together with the sender's ephemeral key to perform ECDH and obtain the shared secret for decrypting the onion payload. Separately, for decrypting `encrypted_recipient_data`, the recipient performs ECDH between its static node private key and the path_key to derive the decryption key.	bytes	string
onion Serialized Sphinx onion packet (BOLT 4) containing the layered, per-hop encrypted payloads and routing instructions used to forward this message along its designated path.	bytes	string
reply_path reply_path is the blinded path that should be used when replying to a received message.	BlindedPath	object
encrypted_recipient_data encrypted_recipient_data is the encrypted data that contains the forwarding information for an onion message. It contains either next_node_id or short_channel_id for each non-final node. It MAY contain the path_id for the final node.	bytes	string
custom_records Custom onion message tlv records. These are customized fields that are not defined by LND and cannot be extracted.	CustomRecordsEntry[]	object

Nested Messages

lnrpc.BlindedHop

Field	gRPC Type	REST Type
blinded_node The blinded public key of the node.	bytes	string
encrypted_data An encrypted blob of data provided to the blinded node.	bytes	string

lnrpc.BlindedPath

Field	gRPC Type	REST Type
introduction_node The unblinded pubkey of the introduction node for the route.	bytes	string
blinding_point The ephemeral pubkey used by nodes in the blinded route.	bytes	string
blinded_hops A set of blinded node keys and data blobs for the blinded portion of the route. Note that the first hop is expected to be the introduction node, so the route is always expected to have at least one hop.	BlindedHop[]	array

lnrpc.OnionMessageUpdate.CustomRecordsEntry

Field	gRPC Type	REST Type
key	uint64	unknown
value	bytes	unknown