SubscribeRfqEventNtfns

SubscribeRfqEventNtfns is used to subscribe to RFQ events.

Source: rfqrpc/rfq.proto

gRPC

info

This is a server-streaming RPC

rpc SubscribeRfqEventNtfns (SubscribeRfqEventNtfnsRequest) returns (stream RfqEvent);

REST

HTTP Method	Path
POST	/v1/taproot-assets/rfq/ntfs

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 = 'TAPROOT-ASSETS_DIR/regtest/taproot-assets.macaroon'
const TLS_PATH = 'TAPROOT-ASSETS_DIR/tls.cert'

const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true,
};
const packageDefinition = protoLoader.loadSync('rfqrpc/rfq.proto', loaderOptions);
const rfqrpc = grpc.loadPackageDefinition(packageDefinition).rfqrpc;
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 rfqrpc.Rfq(GRPC_HOST, creds);
let request = {};
let call = client.subscribeRfqEventNtfns(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_accepted_buy_quote": <PeerAcceptedBuyQuoteEvent>,
//    "peer_accepted_sell_quote": <PeerAcceptedSellQuoteEvent>,
//    "accept_htlc": <AcceptHtlcEvent>,
//  }

Python

import codecs, grpc, os
# Generate the following 2 modules by compiling the rfqrpc/rfq.proto with the grpcio-tools.
# See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
import rfq_pb2 as rfqrpc, rfq_pb2_grpc as rfqstub

GRPC_HOST = 'localhost:10029'
MACAROON_PATH = 'TAPROOT-ASSETS_DIR/regtest/taproot-assets.macaroon'
TLS_PATH = 'TAPROOT-ASSETS_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 = rfqstub.RfqStub(channel)
request = rfqrpc.SubscribeRfqEventNtfnsRequest()
for response in stub.SubscribeRfqEventNtfns(request):
  print(response)
# {
#    "peer_accepted_buy_quote": <PeerAcceptedBuyQuoteEvent>,
#    "peer_accepted_sell_quote": <PeerAcceptedSellQuoteEvent>,
#    "accept_htlc": <AcceptHtlcEvent>,
# }

REST

Javascript

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

const REST_HOST = 'localhost:8089'
const MACAROON_PATH = 'TAPROOT-ASSETS_DIR/regtest/taproot-assets.macaroon'

let requestBody = {
};
let options = {
  url: `https://${REST_HOST}/v1/taproot-assets/rfq/ntfs`,
  // 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:
//  {
//    "peer_accepted_buy_quote": <object>, // <PeerAcceptedBuyQuoteEvent> 
//    "peer_accepted_sell_quote": <object>, // <PeerAcceptedSellQuoteEvent> 
//    "accept_htlc": <object>, // <AcceptHtlcEvent> 
//  }



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

const REST_HOST = 'localhost:8089'
const MACAROON_PATH = 'TAPROOT-ASSETS_DIR/regtest/taproot-assets.macaroon'

let ws = new WebSocket(`wss://${REST_HOST}/v1/taproot-assets/rfq/ntfs?method=POST`, {
  // 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_accepted_buy_quote": <object>, // <PeerAcceptedBuyQuoteEvent>
//    "peer_accepted_sell_quote": <object>, // <PeerAcceptedSellQuoteEvent>
//    "accept_htlc": <object>, // <AcceptHtlcEvent>
//  }

Python

import base64, codecs, json, requests

REST_HOST = 'localhost:8089'
MACAROON_PATH = 'TAPROOT-ASSETS_DIR/regtest/taproot-assets.macaroon'
TLS_PATH = 'TAPROOT-ASSETS_DIR/tls.cert'

url = f'https://{REST_HOST}/v1/taproot-assets/rfq/ntfs'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
data = {
}
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)
# {
#    "peer_accepted_buy_quote": <PeerAcceptedBuyQuoteEvent>,
#    "peer_accepted_sell_quote": <PeerAcceptedSellQuoteEvent>,
#    "accept_htlc": <AcceptHtlcEvent>,
# }

Shell

# There is no CLI command for this RPC

Messages

rfqrpc.SubscribeRfqEventNtfnsRequest

Source: rfqrpc/rfq.proto

note

This request has no parameters.

rfqrpc.RfqEvent

Source: rfqrpc/rfq.proto

Field	gRPC Type	REST Type
peer_accepted_buy_quote peer_accepted_buy_quote is an event that is emitted when a peer accepted (incoming) asset buy quote message is received.	PeerAcceptedBuyQuoteEvent	object
peer_accepted_sell_quote peer_accepted_sell_offer is an event that is emitted when a peer accepted (incoming) asset sell quote message is received.	PeerAcceptedSellQuoteEvent	object
accept_htlc accept_htlc is an event that is sent when a HTLC is accepted by the RFQ service.	AcceptHtlcEvent	object

Nested Messages

rfqrpc.AcceptHtlcEvent

Field	gRPC Type	REST Type
timestamp Unix timestamp in microseconds.	uint64	string
scid scid is the short channel ID of the channel over which the payment for the quote is made.	uint64	string

rfqrpc.FixedPoint

Field	gRPC Type	REST Type
coefficient The coefficient is the fractional value scaled-up as an integer. This integer is represented as a string as it may be too large to fit in a uint64.	string	string
scale The scale is the component that determines how many decimal places the coefficient should be divided by to obtain the fractional value.	uint32	integer

rfqrpc.PeerAcceptedBuyQuote

Field	gRPC Type	REST Type
peer Quote counterparty peer.	string	string
id The unique identifier of the quote request.	bytes	string
scid The short channel ID of the channel over which the payment for the quote should be made.	uint64	string
asset_max_amount The maximum exchange amount denoted in the subject asset. This includes the user-configured maximum routing fees, so the actual payment amount will be less than this. This just defines the maximum volume that the edge node has accepted to divest with the given rate.	uint64	string
ask_asset_rate ask_asset_rate is the asset to BTC conversion rate represented as a fixed-point number.	FixedPoint	object
expiry The unix timestamp in seconds after which the quote is no longer valid.	uint64	string
min_transportable_units The smallest amount of asset units that can be transported within a single HTLC over the Lightning Network with the given rate. This is the asset unit equivalent of 354 satoshis, which is the minimum amount for an HTLC to be above the dust limit.	uint64	string

rfqrpc.PeerAcceptedBuyQuoteEvent

Field	gRPC Type	REST Type
timestamp Unix timestamp in microseconds.	uint64	string
peer_accepted_buy_quote The asset buy quote that was accepted by out peer.	PeerAcceptedBuyQuote	object

rfqrpc.PeerAcceptedSellQuote

Field	gRPC Type	REST Type
peer Quote counterparty peer.	string	string
id The unique identifier of the quote request.	bytes	string
scid scid is the short channel ID of the channel over which the payment for the quote should be made.	uint64	string
asset_amount asset_amount is the amount of the subject asset.	uint64	string
bid_asset_rate bid_asset_rate is the asset to BTC conversion rate represented as a fixed-point number.	FixedPoint	object
expiry The unix timestamp in seconds after which the quote is no longer valid.	uint64	string
min_transportable_msat The minimum amount of milli-satoshis that need to be sent out in order to transport a single asset unit over the Lightning Network with the given rate. This is the base amount of 354,000 milli-satoshi (the minimum amount for a non-dust HTLC) plus the equivalent of one asset unit in milli-satoshis.	uint64	string

rfqrpc.PeerAcceptedSellQuoteEvent

Field	gRPC Type	REST Type
timestamp Unix timestamp in microseconds.	uint64	string
peer_accepted_sell_quote The asset sell quote that was accepted by out peer.	PeerAcceptedSellQuote	object