SealBatch

tapcli assets mint seal SealBatch will attempt to seal the current pending batch by creating and validating asset group witness for all assets in the batch. If a witness is not provided, a signature will be derived to serve as the witness. This RPC is only needed if any assets in the batch have a custom asset group key that require an external signer. Otherwise, FinalizeBatch can be called directly.

Source: mintrpc/mint.proto

gRPC

rpc SealBatch (SealBatchRequest) returns (SealBatchResponse);

REST

HTTP Method	Path
POST	/v1/taproot-assets/assets/mint/seal

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>,
  group_witnesses: <GroupWitness>,
  signed_group_virtual_psbts: <string>,
};
client.sealBatch(request, function(err, response) {
  console.log(response);
});
// Console output:
//  {
//    "batch": <MintingBatch>,
//  }

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.SealBatchRequest(
  short_response=<bool>,
  group_witnesses=<GroupWitness>,
  signed_group_virtual_psbts=<string>,
)
response = stub.SealBatch(request)
print(response)
# {
#    "batch": <MintingBatch>,
# }

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> 
  group_witnesses: <array>, // <GroupWitness> 
  signed_group_virtual_psbts: <array>, // <string> 
};
let options = {
  url: `https://${REST_HOST}/v1/taproot-assets/assets/mint/seal`,
  // 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:
//  {
//    "batch": <object>, // <MintingBatch> 
//  }

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/assets/mint/seal'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
data = {
  'short_response': <bool>,
  'group_witnesses': <GroupWitness>,
  'signed_group_virtual_psbts': <string>,
}
r = requests.post(url, headers=headers, data=json.dumps(data), verify=TLS_PATH)
print(r.json())
# {
#    "batch": <MintingBatch>,
# }

Shell

# There is no CLI command for this RPC

Messages

mintrpc.SealBatchRequest

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 response. 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
group_witnesses The assetID, witness pairs that authorize asset membership in a group. This field should not be used in conjunction with `signed_group_virtual_psbts`; use one or the other.	GroupWitness[]	array	body
signed_group_virtual_psbts The base64 encoded signed group virtual PSBTs. This field should not be used in conjunction with `group_witnesses`; use one or the other.	string[]	array	body

mintrpc.SealBatchResponse

Source: mintrpc/mint.proto

Field	gRPC Type	REST Type
batch The sealed batch.	MintingBatch	object

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

Field	gRPC Type	REST Type
genesis_id The asset ID of the pending asset that should be assigned this asset group witness.	bytes	string
witness The serialized witness stack for the asset group.	bytes[]	array

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
type The type of the script key. This type is either user-declared when custom script keys are added, or automatically determined by the daemon for standard operations (e.g. BIP-86 keys, burn keys, tombstone keys, channel related keys).	ScriptKeyType	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

taprpc.ScriptKeyType

Name	Number
SCRIPT_KEY_UNKNOWN The type of script key is not known. This should only be stored for assets where we don't know the internal key of the script key (e.g. for imported proofs).	0
SCRIPT_KEY_BIP86 The script key is a normal BIP-86 key. This means that the internal key is turned into a Taproot output key by applying a BIP-86 tweak to it.	1
SCRIPT_KEY_SCRIPT_PATH_EXTERNAL The script key is a key that contains a script path that is defined by the user and is therefore external to the tapd wallet. Spending this key requires providing a specific witness and must be signed through the vPSBT signing flow.	2
SCRIPT_KEY_BURN The script key is a specific un-spendable key that indicates a burnt asset. Assets with this key type can never be spent again, as a burn key is a tweaked NUMS key that nobody knows the private key for.	3
SCRIPT_KEY_TOMBSTONE The script key is a specific un-spendable key that indicates a tombstone output. This is only the case for zero-value assets that result from a non-interactive (TAP address) send where no change was left over.	4
SCRIPT_KEY_CHANNEL The script key is used for an asset that resides within a Taproot Asset Channel. That means the script key is either a funding key (OP_TRUE), a commitment output key (to_local, to_remote, htlc), or a HTLC second-level transaction output key. Keys related to channels are not shown in asset balances (unless specifically requested) and are never used for coin selection.	5
SCRIPT_KEY_UNIQUE_PEDERSEN The script key is derived using the asset ID and a single leaf that contains an un-spendable Pedersen commitment key `(OP_CHECKSIG <NUMS_key + asset_id * G>)`. This can be used to create unique script keys for each virtual packet in the fragment, to avoid proof collisions in the universe, where the script keys should be spendable by a hardware wallet that only supports miniscript policies for signing P2TR outputs.	6