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
   finalize, f  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)
   --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 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

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

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

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