SubscribeInvoices

SubscribeInvoices is a wrapper around lnd's lnrpc.SubscribeInvoices method that only streams invoices that involve at least one Taproot Asset. The full lnd invoice is returned along with the decoded asset amounts that the invoice's HTLCs carry, so that callers don't need to parse the custom channel data themselves. All request fields behave the same way as they do for lnd's lnrpc.SubscribeInvoices RPC method.

Source: tapchannelrpc/tapchannel.proto

gRPC

info

This is a server-streaming RPC

rpc SubscribeInvoices (SubscribeInvoicesRequest) returns (stream AssetInvoice);

REST

HTTP Method	Path
POST	/v1/taproot-assets/channels/invoices/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:10029'
const MACAROON_PATH = 'TAPD_DIR/data/regtest/admin.macaroon'
const TLS_PATH = 'TAPD_DIR/tls.cert'

const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true,
};
const packageDefinition = protoLoader.loadSync('tapchannelrpc/tapchannel.proto', loaderOptions);
const tapchannelrpc = grpc.loadPackageDefinition(packageDefinition).tapchannelrpc;
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 tapchannelrpc.TaprootAssetChannels(GRPC_HOST, creds);
let request = {
  request: <InvoiceSubscription>,
};
let call = client.subscribeInvoices(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:
//  {
//    "invoice": <Invoice>,
//    "asset_amounts": <AssetAmount>,
//  }

Python

import codecs, grpc, os
# Generate the following 2 modules by compiling the tapchannelrpc/tapchannel.proto with the grpcio-tools.
# See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
import tapchannel_pb2 as tapchannelrpc, tapchannel_pb2_grpc as tapchannelstub

GRPC_HOST = 'localhost:10029'
MACAROON_PATH = 'TAPD_DIR/data/regtest/admin.macaroon'
TLS_PATH = 'TAPD_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 = tapchannelstub.TaprootAssetChannelsStub(channel)
request = tapchannelrpc.SubscribeInvoicesRequest(
  request=<InvoiceSubscription>,
)
for response in stub.SubscribeInvoices(request):
  print(response)
# {
#    "invoice": <Invoice>,
#    "asset_amounts": <AssetAmount>,
# }

grpcurl

# grpcurl docs: https://github.com/fullstorydev/grpcurl
# Proto source: https://github.com/lightninglabs/taproot-assets
# Also requires: https://github.com/lightningnetwork/lnd
GRPC_HOST=localhost:10029
TAPD_DIR=~/.tapd
TAPD_SOURCE=path/to/taproot-assets
LND_SOURCE=path/to/lnd
NETWORK=mainnet
MACAROON_PATH="$TAPD_DIR/data/$NETWORK/admin.macaroon"
TLS_PATH="$TAPD_DIR/tls.cert"

grpcurl \
    -import-path $TAPD_SOURCE/taprpc/ \
    -import-path $LND_SOURCE/lnrpc \
    -proto tapchannelrpc/tapchannel.proto \
    -cacert $TLS_PATH \
    -H "macaroon: $(xxd -ps -u -c 1000 $MACAROON_PATH)" \
    -d '{ "request": <InvoiceSubscription> }' \
    $GRPC_HOST \
    tapchannelrpc.TaprootAssetChannels/SubscribeInvoices

REST

Javascript

const fs = require('fs');
const request = require('request');

const REST_HOST = 'localhost:8089'
const MACAROON_PATH = 'TAPD_DIR/data/regtest/admin.macaroon'

let requestBody = {
  request: <object>, // <InvoiceSubscription> 
};
let options = {
  url: `https://${REST_HOST}/v1/taproot-assets/channels/invoices/subscribe`,
  // 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:
//  {
//    "invoice": <object>, // <Invoice> 
//    "asset_amounts": <array>, // <AssetAmount> 
//  }



// --------------------------
// Example with websockets:
// --------------------------
const WebSocket = require('ws');
const fs = require('fs');

const REST_HOST = 'localhost:8089'
const MACAROON_PATH = 'TAPD_DIR/data/regtest/admin.macaroon'

let ws = new WebSocket(`wss://${REST_HOST}/v1/taproot-assets/channels/invoices/subscribe?method=POST`, {
  // Work-around for self-signed certificates.
  rejectUnauthorized: false,
  headers: {
    'Grpc-Metadata-Macaroon': fs.readFileSync(MACAROON_PATH).toString('hex'),
  },
});
let requestBody = {
  request: <InvoiceSubscription>, // <InvoiceSubscription> 
};
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:
//  {
//    "invoice": <object>, // <Invoice>
//    "asset_amounts": <array>, // <AssetAmount>
//  }

Python

import base64, codecs, json, requests

REST_HOST = 'localhost:8089'
MACAROON_PATH = 'TAPD_DIR/data/regtest/admin.macaroon'
TLS_PATH = 'TAPD_DIR/tls.cert'

url = f'https://{REST_HOST}/v1/taproot-assets/channels/invoices/subscribe'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
data = {
  'request': <InvoiceSubscription>,
}
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)
# {
#    "invoice": <Invoice>,
#    "asset_amounts": <AssetAmount>,
# }

curl

REST_HOST=localhost:8089
TAPD_DIR=~/.tapd
NETWORK=mainnet
MACAROON_PATH="$TAPD_DIR/data/$NETWORK/admin.macaroon"
TLS_PATH="$TAPD_DIR/tls.cert"

curl -X POST \
    --cacert $TLS_PATH \
    -H "Grpc-Metadata-macaroon: $(xxd -ps -u -c 1000 $MACAROON_PATH)" \
    -d '{ "request": <InvoiceSubscription> }' \
    https://$REST_HOST/v1/taproot-assets/channels/invoices/subscribe

Messages

tapchannelrpc.SubscribeInvoicesRequest

Source: tapchannelrpc/tapchannel.proto

Field	gRPC Type	REST Type	REST Placement
request The standard lnd invoice subscription request. All fields behave the same way as they do for lnd's lnrpc.SubscribeInvoices RPC method (see the API docs at https://lightning.engineering/api-docs/api/lnd/lightning/subscribe-invoices for more details). Invoice index replay is performed by lnd over all invoices; the returned stream is then filtered down to only those that involve assets.	InvoiceSubscription	object	body

tapchannelrpc.AssetInvoice

Source: tapchannelrpc/tapchannel.proto

Field	gRPC Type	REST Type
invoice The full lnd invoice, including any custom channel data on its HTLCs.	Invoice	object
asset_amounts The asset amounts carried by the invoice's HTLCs, aggregated per asset ID across all of the invoice's HTLCs. Empty for invoices that have not been (partially) settled with assets yet.	AssetAmount[]	array

Nested Messages

tapchannelrpc.AssetAmount

Field	gRPC Type	REST Type
asset_id The asset ID (genesis ID of the tranche) the amount refers to.	bytes	string
amount The amount, expressed in units of the asset identified by asset_id.	uint64	string
group_key The tweaked group key the asset belongs to, in compressed form. Empty for assets that aren't part of a group, or whose group is unknown to this tapd instance. Populated so callers that work in terms of group keys (e.g. wallets backing a fungible group of tranches) don't need a separate lookup per result.	bytes	string