ExportProof

ExportProof exports the latest raw proof file anchored at the specified script_key.

Source: taprootassets.proto

gRPC

rpc ExportProof (ExportProofRequest) returns (ProofFile);

REST

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

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>,
  script_key: <bytes>,
  outpoint: <OutPoint>,
};
client.exportProof(request, function(err, response) {
  console.log(response);
});
// Console output:
//  {
//    "raw_proof_file": <bytes>,
//    "genesis_point": <string>,
//  }

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.ExportProofRequest(
  asset_id=<bytes>,
  script_key=<bytes>,
  outpoint=<OutPoint>,
)
response = stub.ExportProof(request)
print(response)
# {
#    "raw_proof_file": <bytes>,
#    "genesis_point": <string>,
# }

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)
  script_key: <string>, // <bytes> (base64 encoded)
  outpoint: <object>, // <OutPoint> 
};
let options = {
  url: `https://${REST_HOST}/v1/taproot-assets/proofs/export`,
  // 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:
//  {
//    "raw_proof_file": <string>, // <bytes> 
//    "genesis_point": <string>, // <string> 
//  }

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/proofs/export'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
data = {
  'asset_id': base64.b64encode(<bytes>),
  'script_key': base64.b64encode(<bytes>),
  'outpoint': <OutPoint>,
}
r = requests.post(url, headers=headers, data=json.dumps(data), verify=TLS_PATH)
print(r.json())
# {
#    "raw_proof_file": <bytes>,
#    "genesis_point": <string>,
# }

Shell

$ tapcli proofs export --help

NAME:
   tapcli proofs export - export a taproot asset proof

USAGE:
   tapcli proofs export [command options] [arguments...]

DESCRIPTION:
   
  Export a taproot asset proof that contains the full provenance of an
  asset. Such a proof proves the existence of an asset, but does not
  prove that the creator of the proof can actually also spend the asset.
  To prove ownership, use the "proveownership" command to produce a
  separate ownership proof.
  

OPTIONS:
   --asset_id value    the asset ID of the asset to export
   --script_key value  the script key of the asset to export
   --proof_file value  (optional) the file to write the raw proof to; use the dash character (-) to write the raw binary proof to stdout instead of the default JSON format
   

Messages

taprpc.ExportProofRequest

Source: taprootassets.proto

Field	gRPC Type	REST Type	REST Placement
asset_id	bytes	string	body
script_key	bytes	string	body
outpoint	OutPoint	object	body

taprpc.ProofFile

Source: taprootassets.proto

Field	gRPC Type	REST Type
raw_proof_file The raw proof file encoded as bytes. Must be a file and not just an individual mint/transfer proof.	bytes	string
genesis_point	string	string

Nested Messages

taprpc.OutPoint

Field	gRPC Type	REST Type
txid Raw bytes representing the transaction id.	bytes	string
output_index The index of the output on the transaction.	uint32	integer