MintAsset

MintAsset will attempt to mint the set of assets (async by default to ensure proper batching) specified in the request. The pending batch is returned that shows the other pending assets that are part of the next batch. This call will block until the operation succeeds (asset is staged in the batch) or fails.

Source: mintrpc/mint.proto

gRPC

rpc MintAsset (MintAssetRequest) returns (MintAssetResponse);

REST

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

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 = {
  asset: <MintAsset>,
  short_response: <bool>,
};
client.mintAsset(request, function(err, response) {
  console.log(response);
});
// Console output:
//  {
//    "pending_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.MintAssetRequest(
  asset=<MintAsset>,
  short_response=<bool>,
)
response = stub.MintAsset(request)
print(response)
# {
#    "pending_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 = {
  asset: <object>, // <MintAsset> 
  short_response: <boolean>, // <bool> 
};
let options = {
  url: `https://${REST_HOST}/v1/taproot-assets/assets`,
  // 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:
//  {
//    "pending_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'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
data = {
  'asset': <MintAsset>,
  'short_response': <bool>,
}
r = requests.post(url, headers=headers, data=json.dumps(data), verify=TLS_PATH)
print(r.json())
# {
#    "pending_batch": <MintingBatch>,
# }

Shell

$ tapcli assets mint --help

NAME:
   tapcli assets mint - Attempt to mint a new asset with the specified parameters

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

COMMANDS:
   batches, b  list all batches
   fund        fund a batch
   finalize    finalize a batch
   cancel, c   cancel a batch

OPTIONS:
   --type value             the type of asset, must either be: normal, or collectible
   --name value             the name/tag of the asset
   --supply value           the target supply of the minted asset (default: 0)
   --decimal_display value  the number of decimal places, asset amounts, are shift to the left converting asset integer amountsinto UI-recognizable fractional quantity (e.g. an asset with amount100 and decimal display of 2 is displayed as 1.00 in the wallet) (default: 0)
   --asset_version value    the version of the asset to mint (default: 0)
   --meta_bytes value       the raw metadata associated with the asset
   --meta_file_path value   a path to a file on disk that should be read and used as the asset meta
   --meta_type value        the type of the meta data for the asset, must be either: opaque or json (default: "opaque")
   --new_grouped_asset      if true, then the asset supports on going emission
   --grouped_asset          if true, then the asset is minted into a specific group
   --group_key value        the specific group key to use to mint the asset
   --group_anchor value     the other asset in this batch that the new asset be grouped with
   --short                  if true, then the current assets within the batch will not be returned in the response in order to avoid printing a large amount of data in case of large batches
   --help, -h               show help
   

Messages

mintrpc.MintAssetRequest

Source: mintrpc/mint.proto

Field	gRPC Type	REST Type	REST Placement
asset The asset to be minted.	MintAsset	object	body
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

mintrpc.MintAssetResponse

Source: mintrpc/mint.proto

Field	gRPC Type	REST Type
pending_batch The pending batch the asset was added to.	MintingBatch	object

Nested Messages

mintrpc.MintAsset

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 group key, which allows for future asset issuance.	bool	boolean
grouped_asset If true, then a group key or group anchor can be set to mint this asset into an existing asset group.	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
decimal_display Decimal display dictates the number of decimal places to shift the amount to the left converting from Taproot Asset integer representation to a UX-recognizable fractional quantity. For example, if the decimal_display value is 2 and there's 100 of those assets, then a wallet would display the amount as "1.00". This field is intended as information for wallets that display balances and has no impact on the behavior of the daemon or any other part of the protocol. This value is encoded in the MetaData field as a JSON field, therefore it is only compatible with assets that have a JSON MetaData field.	uint32	integer

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