NextScriptKey

NextScriptKey derives the next script key (and its corresponding internal key) and stores them both in the database to make sure they are identified as local keys later on when importing proofs.

Source: assetwalletrpc/assetwallet.proto

gRPC

rpc NextScriptKey (NextScriptKeyRequest) returns (NextScriptKeyResponse);

REST

HTTP Method	Path
POST	/v1/taproot-assets/wallet/script-key/next

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 = 'TAPD_DIR/data/regtest/admin.macaroon'
const TLS_PATH = 'TAPD_DIR/tls.cert'

const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true,
};
const packageDefinition = protoLoader.loadSync('assetwalletrpc/assetwallet.proto', loaderOptions);
const assetwalletrpc = grpc.loadPackageDefinition(packageDefinition).assetwalletrpc;
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 assetwalletrpc.AssetWallet(GRPC_HOST, creds);
let request = {
  key_family: <uint32>,
};
client.nextScriptKey(request, function(err, response) {
  console.log(response);
});
// Console output:
//  {
//    "script_key": <ScriptKey>,
//  }

Python

import codecs, grpc, os
# Generate the following 2 modules by compiling the assetwalletrpc/assetwallet.proto with the grpcio-tools.
# See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
import assetwallet_pb2 as assetwalletrpc, assetwallet_pb2_grpc as assetwalletstub

GRPC_HOST = 'localhost:10029'
MACAROON_PATH = 'TAPD_DIR/data/regtest/admin.macaroon'
TLS_PATH = 'TAPD_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 = assetwalletstub.AssetWalletStub(channel)
request = assetwalletrpc.NextScriptKeyRequest(
  key_family=<uint32>,
)
response = stub.NextScriptKey(request)
print(response)
# {
#    "script_key": <ScriptKey>,
# }

grpcurl

# grpcurl docs: https://github.com/fullstorydev/grpcurl
# Proto source: https://github.com/lightninglabs/taproot-assets
GRPC_HOST=localhost:10029
TAPD_DIR=~/.tapd
TAPD_SOURCE=path/to/taproot-assets
NETWORK=mainnet
MACAROON_PATH="$TAPD_DIR/data/$NETWORK/admin.macaroon"
TLS_PATH="$TAPD_DIR/tls.cert"

grpcurl \
    -import-path $TAPD_SOURCE/taprpc/ \
    -proto assetwalletrpc/assetwallet.proto \
    -cacert $TLS_PATH \
    -H "macaroon: $(xxd -ps -u -c 1000 $MACAROON_PATH)" \
    -d '{ "key_family": <uint32> }' \
    $GRPC_HOST \
    assetwalletrpc.AssetWallet/NextScriptKey

REST

Javascript

const fs = require('fs');
const request = require('request');

const REST_HOST = 'localhost:8089'
const MACAROON_PATH = 'TAPD_DIR/data/regtest/admin.macaroon'

let requestBody = {
  key_family: <integer>, // <uint32> 
};
let options = {
  url: `https://${REST_HOST}/v1/taproot-assets/wallet/script-key/next`,
  // 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:
//  {
//    "script_key": <object>, // <ScriptKey> 
//  }

Python

import base64, codecs, json, requests

REST_HOST = 'localhost:8089'
MACAROON_PATH = 'TAPD_DIR/data/regtest/admin.macaroon'
TLS_PATH = 'TAPD_DIR/tls.cert'

url = f'https://{REST_HOST}/v1/taproot-assets/wallet/script-key/next'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
data = {
  'key_family': <uint32>,
}
r = requests.post(url, headers=headers, data=json.dumps(data), verify=TLS_PATH)
print(r.json())
# {
#    "script_key": <ScriptKey>,
# }

curl

REST_HOST=localhost:8089
TAPD_DIR=~/.tapd
NETWORK=mainnet
MACAROON_PATH="$TAPD_DIR/data/$NETWORK/admin.macaroon"
TLS_PATH="$TAPD_DIR/tls.cert"

curl -X POST \
    --cacert $TLS_PATH \
    -H "Grpc-Metadata-macaroon: $(xxd -ps -u -c 1000 $MACAROON_PATH)" \
    -d '{ "key_family": <uint32> }' \
    https://$REST_HOST/v1/taproot-assets/wallet/script-key/next

Messages

assetwalletrpc.NextScriptKeyRequest

Source: assetwalletrpc/assetwallet.proto

Field	gRPC Type	REST Type	REST Placement
key_family The key family to derive the next script key for.	uint32	integer	body

assetwalletrpc.NextScriptKeyResponse

Source: assetwalletrpc/assetwallet.proto

Field	gRPC Type	REST Type
script_key The full script key information that was derived, including the internal key and the tweaked script key.	ScriptKey	object

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, as a 32-byte x-only (Schnorr) public key. 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

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