FundBatch

tapcli assets mint fund FundBatch will attempt to fund the current pending batch with a genesis input, or create a new funded batch if no batch exists yet. This RPC is only needed if a custom witness is needed to finalize the batch. Otherwise, FinalizeBatch can be called directly.

Source: mintrpc/mint.proto

gRPC

rpc FundBatch (FundBatchRequest) returns (FundBatchResponse);

REST

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

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>,
  fee_rate: <uint32>,
  full_tree: <TapscriptFullTree>,
  branch: <TapBranch>,
};
client.fundBatch(request, function(err, response) {
  console.log(response);
});
// Console output:
//  {
//    "batch": <VerboseBatch>,
//  }

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.FundBatchRequest(
  short_response=<bool>,
  fee_rate=<uint32>,
  full_tree=<TapscriptFullTree>,
  branch=<TapBranch>,
)
response = stub.FundBatch(request)
print(response)
# {
#    "batch": <VerboseBatch>,
# }

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> 
  fee_rate: <integer>, // <uint32> 
  full_tree: <object>, // <TapscriptFullTree> 
  branch: <object>, // <TapBranch> 
};
let options = {
  url: `https://${REST_HOST}/v1/taproot-assets/assets/mint/fund`,
  // 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>, // <VerboseBatch> 
//  }

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/fund'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
data = {
  'short_response': <bool>,
  'fee_rate': <uint32>,
  'full_tree': <TapscriptFullTree>,
  'branch': <TapBranch>,
}
r = requests.post(url, headers=headers, data=json.dumps(data), verify=TLS_PATH)
print(r.json())
# {
#    "batch": <VerboseBatch>,
# }

Shell

# There is no CLI command for this RPC

Messages

mintrpc.FundBatchRequest

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
fee_rate The optional fee rate to use for the minting transaction, in sat/kw.	uint32	integer	body
full_tree An ordered list of TapLeafs, which will be used to construct a Tapscript tree.	TapscriptFullTree	object	body
branch A TapBranch that represents a Tapscript tree managed externally.	TapBranch	object	body

mintrpc.FundBatchResponse

Source: mintrpc/mint.proto

Field	gRPC Type	REST Type
batch The funded batch.	VerboseBatch	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

mintrpc.UnsealedAsset

Field	gRPC Type	REST Type
asset The pending asset with an unsealed asset group.	PendingAsset	object
group_key_request The group key request for the asset.	GroupKeyRequest	object
group_virtual_tx The group virtual transaction for the asset.	GroupVirtualTx	object
group_virtual_psbt The byte serialized PSBT equivalent of the group virtual transaction.	string	string

mintrpc.VerboseBatch

Field	gRPC Type	REST Type
batch The minting batch, without any assets.	MintingBatch	object
unsealed_assets The assets that are part of the batch.	UnsealedAsset[]	array

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

Field	gRPC Type	REST Type
xpub This field specifies the extended public key derived at depth 3 of the BIP-86 hierarchy (e.g., m/86'/0'/0'). This key serves as the parent key for deriving child public keys and addresses.	string	string
master_fingerprint This field specifies the fingerprint of the master key, derived from the first 4 bytes of the hash160 of the master public key. It is used to identify the master key in BIP-86 derivation schemes.	bytes	string
derivation_path This field specifies the extended BIP-86 derivation path used to derive a child key from the XPub. Starting from the base path of the XPub (e.g., m/86'/0'/0'), this path must contain exactly 5 components in total (e.g., m/86'/0'/0'/0/0), with the additional components defining specific child keys, such as individual addresses.	string	string

taprpc.GenesisInfo

Field	gRPC Type	REST Type
genesis_point The first outpoint of the transaction that created the asset (txid:vout).	string	string
name The name of the asset.	string	string
meta_hash The hash of the meta data for this genesis asset.	bytes	string
asset_id The asset ID that uniquely identifies the asset.	bytes	string
asset_type The type of the asset.	AssetType	string
output_index The index of the output that carries the unique Taproot Asset commitment in the genesis transaction.	uint32	integer

taprpc.GroupKeyRequest

Field	gRPC Type	REST Type
raw_key The internal key for the asset group before any tweaks have been applied. If this field is set then external_key must be empty, and vice versa.	KeyDescriptor	object
anchor_genesis The genesis of the group anchor asset, which is used to derive the single tweak for the group key. For a new group key, this will be the genesis of new_asset.	GenesisInfo	object
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
new_asset The serialized asset which we are requesting group membership for. A successful request will produce a witness that authorizes this asset to be a member of this asset group.	bytes	string
external_key The external key is an optional field that allows specifying an external signing key for the group virtual transaction during minting. This key enables signing operations to be performed externally, outside the daemon. If this field is set then raw_key must be empty, and vice versa.	ExternalKey	object

taprpc.GroupVirtualTx

Field	gRPC Type	REST Type
transaction The virtual transaction that represents the genesis state transition of a grouped asset.	bytes	string
prev_out The transaction output that represents a grouped asset. The tweaked group key is set as the PkScript of this output. This is used in combination with Tx to produce an asset group witness.	TxOut	object
genesis_id The asset ID of the grouped asset in a GroupKeyRequest. This ID is needed to construct a sign descriptor, as it is the single tweak for the group internal key.	bytes	string
tweaked_key The tweaked group key for a specific GroupKeyRequest. This is used to construct a complete group key after producing an asset group witness.	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
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

taprpc.TapBranch

Field	gRPC Type	REST Type
left_taphash The TapHash of the left child of the root hash of a Tapscript tree.	bytes	string
right_taphash The TapHash of the right child of the root hash of a Tapscript tree.	bytes	string

taprpc.TapLeaf

Field	gRPC Type	REST Type
script The script of the tap leaf.	bytes	string

taprpc.TapscriptFullTree

Field	gRPC Type	REST Type
all_leaves The complete, ordered list of all tap leaves of the tree.	TapLeaf[]	array

taprpc.TxOut

Field	gRPC Type	REST Type
value The value of the output being spent.	int64	string
pk_script The script of the output being spent.	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

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