SubscribeMintEvents

SubscribeMintEvents allows a caller to subscribe to mint events for asset creation batches.

Source: mintrpc/mint.proto

gRPC

info

This is a server-streaming RPC

rpc SubscribeMintEvents (SubscribeMintEventsRequest) returns (stream MintEvent);

REST

HTTP Method	Path
POST	/v1/taproot-assets/events/asset-mint

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('mintrpc/mint.proto', loaderOptions);
const mintrpc = grpc.loadPackageDefinition(packageDefinition).mintrpc;
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 mintrpc.Mint(GRPC_HOST, creds);
let request = {
  short_response: <bool>,
};
let call = client.subscribeMintEvents(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:
//  {
//    "timestamp": <int64>,
//    "batch_state": <BatchState>,
//    "batch": <MintingBatch>,
//    "error": <string>,
//  }

Python

import codecs, grpc, os
# Generate the following 2 modules by compiling the mintrpc/mint.proto with the grpcio-tools.
# See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
import mint_pb2 as mintrpc, mint_pb2_grpc as mintstub

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 = mintstub.MintStub(channel)
request = mintrpc.SubscribeMintEventsRequest(
  short_response=<bool>,
)
for response in stub.SubscribeMintEvents(request):
  print(response)
# {
#    "timestamp": <int64>,
#    "batch_state": <BatchState>,
#    "batch": <MintingBatch>,
#    "error": <string>,
# }

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 = {
  short_response: <boolean>, // <bool> 
};
let options = {
  url: `https://${REST_HOST}/v1/taproot-assets/events/asset-mint`,
  // 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:
//  {
//    "timestamp": <string>, // <int64> 
//    "batch_state": <string>, // <BatchState> 
//    "batch": <object>, // <MintingBatch> 
//    "error": <string>, // <string> 
//  }



// --------------------------
// 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/events/asset-mint?method=POST`, {
  // Work-around for self-signed certificates.
  rejectUnauthorized: false,
  headers: {
    'Grpc-Metadata-Macaroon': fs.readFileSync(MACAROON_PATH).toString('hex'),
  },
});
let requestBody = {
  short_response: <bool>, // <bool> 
};
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:
//  {
//    "timestamp": <string>, // <int64>
//    "batch_state": <string>, // <BatchState>
//    "batch": <object>, // <MintingBatch>
//    "error": <string>, // <string>
//  }

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/events/asset-mint'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
data = {
  'short_response': <bool>,
}
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)
# {
#    "timestamp": <int64>,
#    "batch_state": <BatchState>,
#    "batch": <MintingBatch>,
#    "error": <string>,
# }

Shell

$ tapcli events mint --help

NAME:
   tapcli events mint - Subscribe to events around minting assets

USAGE:
   tapcli events mint [command options] [arguments...]

DESCRIPTION:
   Get live updates on the status of minting asset batches on the local node. This command will block until aborted manually by hitting Ctrl+C.

OPTIONS:
   --short  if true, then the current assets within the batch of an event will not be returned in the response in order to avoid printing a large amount of data in case of large batches
   

Messages

mintrpc.SubscribeMintEventsRequest

Source: mintrpc/mint.proto

Field	gRPC Type	REST Type	REST Placement
short_response If true, then the assets currently in the batch won't be returned in the event's batch. This is mainly to avoid a lot of data being transmitted and possibly printed on the command line in the case of a very large batch.	bool	boolean	body

mintrpc.MintEvent

Source: mintrpc/mint.proto

Field	gRPC Type	REST Type
timestamp Execute timestamp (Unix timestamp in microseconds).	int64	string
batch_state The last state of the batch that was successfully executed. If error below is set, then the batch_state is the state that lead to the error during its execution.	BatchState	string
batch The batch that the event is for.	MintingBatch	object
error An optional error, indicating that executing the batch_state failed.	string	string

Nested Messages

mintrpc.MintingBatch

Field	gRPC Type	REST Type
batch_key A public key serialized in compressed format that can be used to uniquely identify a pending minting batch. Responses that share the same key will be batched into the same minting transaction.	bytes	string
batch_txid The transaction ID of the batch. Only populated if the batch has been committed.	string	string
state The state of the batch.	BatchState	string
assets The assets that are part of the batch.	PendingAsset[]	array
created_at The time the batch was created as a Unix timestamp (in seconds).	int64	string
height_hint The current height of the block chain at the time of the batch creation.	uint32	integer
batch_psbt The genesis transaction as a PSBT packet. Only populated if the batch has been committed.	bytes	string

mintrpc.PendingAsset

Field	gRPC Type	REST Type
asset_version The version of asset to mint.	AssetVersion	string
asset_type The type of the asset to be created.	AssetType	string
name The name, or "tag" of the asset. This will affect the final asset ID.	string	string
asset_meta A blob that resents metadata related to the asset. This will affect the final asset ID.	AssetMeta	object
amount The total amount of units of the new asset that should be created. If the AssetType is Collectible, then this field cannot be set.	uint64	string
new_grouped_asset If true, then the asset will be created with a new group key, which allows for future asset issuance.	bool	boolean
group_key The specific existing group key this asset should be minted with.	bytes	string
group_anchor The name of the asset in the batch that will anchor a new asset group. This asset will be minted with the same group key as the anchor asset.	string	string
group_internal_key The optional key that will be used as the internal key for an asset group created with this asset.	KeyDescriptor	object
group_tapscript_root The optional root of a tapscript tree that will be used when constructing a new asset group key. This enables future issuance authorized with a script witness.	bytes	string
script_key The optional script key to use for the new asset. If no script key is given, a BIP-86 key will be derived from the underlying wallet.	ScriptKey	object

taprpc.AssetMeta

Field	gRPC Type	REST Type
data The raw data of the asset meta data. Based on the type below, this may be structured data such as a text file or PDF. The size of the data is limited to 1MiB.	bytes	string
type The type of the asset meta data.	AssetMetaType	string
meta_hash The hash of the meta. This is the hash of the TLV serialization of the meta itself.	bytes	string

taprpc.KeyDescriptor

Field	gRPC Type	REST Type
raw_key_bytes The raw bytes of the key being identified.	bytes	string
key_loc The key locator that identifies which key to use for signing.	KeyLocator	object

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

taprpc.ScriptKey

Field	gRPC Type	REST Type
pub_key The full Taproot output key the asset is locked to. This is either a BIP-86 key if the tap_tweak below is empty, or a key with the tap tweak applied to it.	bytes	string
key_desc The key descriptor describing the internal key of the above Taproot key.	KeyDescriptor	object
tap_tweak The optional Taproot tweak to apply to the above internal key. If this is empty then a BIP-86 style tweak is applied to the internal key.	bytes	string

Enums

mintrpc.BatchState

Name	Number
BATCH_STATE_UNKNOWN	0
BATCH_STATE_PENDING	1
BATCH_STATE_FROZEN	2
BATCH_STATE_COMMITTED	3
BATCH_STATE_BROADCAST	4
BATCH_STATE_CONFIRMED	5
BATCH_STATE_FINALIZED	6
BATCH_STATE_SEEDLING_CANCELLED	7
BATCH_STATE_SPROUT_CANCELLED	8

taprpc.AssetMetaType

Name	Number
META_TYPE_OPAQUE Opaque is used for asset meta blobs that have no true structure and instead should be interpreted as opaque blobs.	0
META_TYPE_JSON JSON is used for asset meta blobs that are to be interpreted as valid JSON strings.	1

taprpc.AssetType

Name	Number
NORMAL Indicates that an asset is capable of being split/merged, with each of the units being fungible, even across a key asset ID boundary (assuming the key group is the same).	0
COLLECTIBLE Indicates that an asset is a collectible, meaning that each of the other items under the same key group are not fully fungible with each other. Collectibles also cannot be split or merged.	1

taprpc.AssetVersion

Name	Number
ASSET_VERSION_V0 ASSET_VERSION_V0 is the default asset version. This version will include the witness vector in the leaf for a tap commitment.	0
ASSET_VERSION_V1 ASSET_VERSION_V1 is the asset version that leaves out the witness vector from the MS-SMT leaf encoding.	1