NewAddr

NewAddr makes a new address from the set of request params.

Source: taprootassets.proto

gRPC

rpc NewAddr (NewAddrRequest) returns (Addr);

REST

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

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('taprootassets.proto', loaderOptions);
const taprpc = grpc.loadPackageDefinition(packageDefinition).taprpc;
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 taprpc.TaprootAssets(GRPC_HOST, creds);
let request = {
  asset_id: <bytes>,
  amt: <uint64>,
  script_key: <ScriptKey>,
  internal_key: <KeyDescriptor>,
  tapscript_sibling: <bytes>,
  proof_courier_addr: <string>,
  asset_version: <AssetVersion>,
};
client.newAddr(request, function(err, response) {
  console.log(response);
});
// Console output:
//  {
//    "encoded": <string>,
//    "asset_id": <bytes>,
//    "asset_type": <AssetType>,
//    "amount": <uint64>,
//    "group_key": <bytes>,
//    "script_key": <bytes>,
//    "internal_key": <bytes>,
//    "tapscript_sibling": <bytes>,
//    "taproot_output_key": <bytes>,
//    "proof_courier_addr": <string>,
//    "asset_version": <AssetVersion>,
//  }

Python

import codecs, grpc, os
# Generate the following 2 modules by compiling the taprootassets.proto with the grpcio-tools.
# See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
import taprootassets_pb2 as taprpc, taprootassets_pb2_grpc as taprootassetsstub

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 = taprootassetsstub.TaprootAssetsStub(channel)
request = taprpc.NewAddrRequest(
  asset_id=<bytes>,
  amt=<uint64>,
  script_key=<ScriptKey>,
  internal_key=<KeyDescriptor>,
  tapscript_sibling=<bytes>,
  proof_courier_addr=<string>,
  asset_version=<AssetVersion>,
)
response = stub.NewAddr(request)
print(response)
# {
#    "encoded": <string>,
#    "asset_id": <bytes>,
#    "asset_type": <AssetType>,
#    "amount": <uint64>,
#    "group_key": <bytes>,
#    "script_key": <bytes>,
#    "internal_key": <bytes>,
#    "tapscript_sibling": <bytes>,
#    "taproot_output_key": <bytes>,
#    "proof_courier_addr": <string>,
#    "asset_version": <AssetVersion>,
# }

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_id: <string>, // <bytes> (base64 encoded)
  amt: <string>, // <uint64> 
  script_key: <object>, // <ScriptKey> 
  internal_key: <object>, // <KeyDescriptor> 
  tapscript_sibling: <string>, // <bytes> (base64 encoded)
  proof_courier_addr: <string>, // <string> 
  asset_version: <string>, // <AssetVersion> 
};
let options = {
  url: `https://${REST_HOST}/v1/taproot-assets/addrs`,
  // 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:
//  {
//    "encoded": <string>, // <string> 
//    "asset_id": <string>, // <bytes> 
//    "asset_type": <string>, // <AssetType> 
//    "amount": <string>, // <uint64> 
//    "group_key": <string>, // <bytes> 
//    "script_key": <string>, // <bytes> 
//    "internal_key": <string>, // <bytes> 
//    "tapscript_sibling": <string>, // <bytes> 
//    "taproot_output_key": <string>, // <bytes> 
//    "proof_courier_addr": <string>, // <string> 
//    "asset_version": <string>, // <AssetVersion> 
//  }

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/addrs'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
data = {
  'asset_id': base64.b64encode(<bytes>),
  'amt': <uint64>,
  'script_key': <ScriptKey>,
  'internal_key': <KeyDescriptor>,
  'tapscript_sibling': base64.b64encode(<bytes>),
  'proof_courier_addr': <string>,
  'asset_version': <AssetVersion>,
}
r = requests.post(url, headers=headers, data=json.dumps(data), verify=TLS_PATH)
print(r.json())
# {
#    "encoded": <string>,
#    "asset_id": <bytes>,
#    "asset_type": <AssetType>,
#    "amount": <uint64>,
#    "group_key": <bytes>,
#    "script_key": <bytes>,
#    "internal_key": <bytes>,
#    "tapscript_sibling": <bytes>,
#    "taproot_output_key": <bytes>,
#    "proof_courier_addr": <string>,
#    "asset_version": <AssetVersion>,
# }

Shell

$ tapcli addrs new --help

NAME:
   tapcli addrs new - Create a Taproot Asset address

USAGE:
   tapcli addrs new [command options] [arguments...]

DESCRIPTION:
   Create a new Taproot Asset address to receive an asset on-chain

OPTIONS:
   --asset_id value            the asset genesis ID of the asset to receive
   --amt value                 the amt of the asset to receive (default: 0)
   --asset_version value       the asset version of the asset to receive (default: 0)
   --proof_courier_addr value  (optional) the address of the proof courier to use for this specific address, if the default proof courier should be overwritten; format: protocol://host:port
   

Messages

taprpc.NewAddrRequest

Source: taprootassets.proto

Field	gRPC Type	REST Type	REST Placement
asset_id	bytes	string	body
amt	uint64	string	body
script_key The optional script key that the receiving asset should be locked to. If no script key is provided, a normal BIP-86 key will be derived from the underlying wallet. NOTE: The script_key and internal_key fields should either both be set or both be empty.	ScriptKey	object	body
internal_key The optional internal key of the receiving BTC level transaction output on which the receiving asset transfers will be committed to. If no internal key is provided, a key will be derived from the underlying wallet. NOTE: The script_key and internal_key fields should either both be set or both be empty.	KeyDescriptor	object	body
tapscript_sibling The optional serialized tapscript sibling preimage to use for the receiving asset. This is usually empty as it is only needed when there should be an additional script path in the Taproot tree alongside the Taproot Asset commitment of the asset.	bytes	string	body
proof_courier_addr An optional proof courier address for use in proof transfer. If unspecified, the daemon configured default address will be used.	string	string	body
asset_version The asset version to use when sending/receiving to/from this address.	AssetVersion	string	body

taprpc.Addr

Source: taprootassets.proto

Field	gRPC Type	REST Type
encoded The bech32 encoded Taproot Asset address.	string	string
asset_id The asset ID that uniquely identifies the asset.	bytes	string
asset_type The type of the asset.	AssetType	string
amount The total amount of the asset stored in this Taproot Asset UTXO.	uint64	string
group_key The group key of the asset (if it exists)	bytes	string
script_key The specific script key the asset must commit to in order to transfer ownership to the creator of the address.	bytes	string
internal_key The internal key used for the on-chain output.	bytes	string
tapscript_sibling The optional serialized tapscript sibling preimage to use for the receiving asset. This is usually empty as it is only needed when there should be an additional script path in the Taproot tree alongside the Taproot Asset commitment of the asset.	bytes	string
taproot_output_key The tweaked internal key that commits to the asset and represents the on-chain output key the Bitcoin transaction must send to in order to transfer assets described in this address.	bytes	string
proof_courier_addr The address of the proof courier service used in proof transfer.	string	string
asset_version The asset version of the address.	AssetVersion	string

Nested Messages

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

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