PushProof

PushProof attempts to query the local universe for a proof specified by a UniverseKey. If found, a connection is made to a remote Universe server to attempt to upload the asset leaf.

Source: universerpc/universe.proto

gRPC

rpc PushProof (PushProofRequest) returns (PushProofResponse);

REST

HTTP Method	Path
POST	/v1/taproot-assets/universe/proofs/push/asset-id/{key.id.asset_id_str}/{key.leaf_key.op.hash_str}/{key.leaf_key.op.index}/{key.leaf_key.script_key_str}

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('universerpc/universe.proto', loaderOptions);
const universerpc = grpc.loadPackageDefinition(packageDefinition).universerpc;
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 universerpc.Universe(GRPC_HOST, creds);
let request = {
  key: <UniverseKey>,
  server: <UniverseFederationServer>,
};
client.pushProof(request, function(err, response) {
  console.log(response);
});
// Console output:
//  {
//    "key": <UniverseKey>,
//  }

Python

import codecs, grpc, os
# Generate the following 2 modules by compiling the universerpc/universe.proto with the grpcio-tools.
# See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
import universe_pb2 as universerpc, universe_pb2_grpc as universestub

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 = universestub.UniverseStub(channel)
request = universerpc.PushProofRequest(
  key=<UniverseKey>,
  server=<UniverseFederationServer>,
)
response = stub.PushProof(request)
print(response)
# {
#    "key": <UniverseKey>,
# }

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 = {
  key: <object>, // <UniverseKey> 
  server: <object>, // <UniverseFederationServer> 
};
let options = {
  url: `https://${REST_HOST}/v1/taproot-assets/universe/proofs/push/asset-id/{key.id.asset_id_str}/{key.leaf_key.op.hash_str}/{key.leaf_key.op.index}/{key.leaf_key.script_key_str}`,
  // 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:
//  {
//    "key": <object>, // <UniverseKey> 
//  }

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/universe/proofs/push/asset-id/{key.id.asset_id_str}/{key.leaf_key.op.hash_str}/{key.leaf_key.op.index}/{key.leaf_key.script_key_str}'
macaroon = codecs.encode(open(MACAROON_PATH, 'rb').read(), 'hex')
headers = {'Grpc-Metadata-macaroon': macaroon}
data = {
  'key': <UniverseKey>,
  'server': <UniverseFederationServer>,
}
r = requests.post(url, headers=headers, data=json.dumps(data), verify=TLS_PATH)
print(r.json())
# {
#    "key": <UniverseKey>,
# }

Shell

$ tapcli universe proofs push --help

NAME:
   tapcli universe proofs push - push a proof to a remote Universe

USAGE:
   tapcli universe proofs push [command options] [arguments...]

DESCRIPTION:
   
  Push a proof present in the local Universe to a remote Universe.
  

OPTIONS:
   --asset_id value       the asset ID of the universe to query for
   --group_key value      the group key of the universe to query for
   --outpoint value       the target outpoint on chain to locate a tap proof within
   --script_key value     the script key (scoped to an assetID) to query a proof for
   --proof_type value     the type of proof to query for, either 'issuance' or 'transfer' (default: "issuance")
   --universe_host value  the host:port or just host of the remote universe
   --server_id value      the ID of the universe server in our federation (default: 0)
   

Messages

universerpc.PushProofRequest

Source: universerpc/universe.proto

Field	gRPC Type	REST Type	REST Placement
key The ID of the asset to push the proof for. Nested REST Parameters key: object in body key.id.asset_id_str: string in path key.leaf_key.op.hash_str: string in path key.leaf_key.op.index: integer in path key.leaf_key.script_key_str: string in path	UniverseKey	object	mixed
server The universe server to push the proof to. Nested REST Parameters server: `inbody`	UniverseFederationServer	object	body

universerpc.PushProofResponse

Source: universerpc/universe.proto

Field	gRPC Type	REST Type
key The ID of the asset a push was requested for.	UniverseKey	object

Nested Messages

universerpc.AssetKey

Field	gRPC Type	REST Type
op_str	string	string
op	Outpoint	object
script_key_bytes	bytes	string
script_key_str	string	string

universerpc.ID

Field	gRPC Type	REST Type
asset_id The 32-byte asset ID specified as raw bytes (gRPC only).	bytes	string
asset_id_str The 32-byte asset ID encoded as a hex string (use this for REST).	string	string
group_key The 32-byte asset group key specified as raw bytes (gRPC only).	bytes	string
group_key_str The 32-byte asset group key encoded as hex string (use this for REST).	string	string
proof_type Nested REST Parameters proof_type: string in query	ProofType	string

universerpc.Outpoint

Field	gRPC Type	REST Type
hash_str The output as a hex encoded (and reversed!) string.	string	string
index The index of the output.	int32	integer

universerpc.UniverseFederationServer

Field	gRPC Type	REST Type
host	string	string
id	int32	integer

universerpc.UniverseKey

Field	gRPC Type	REST Type
id The ID of the asset to query for. Nested REST Parameters id.asset_id_str: string in path id.group_key: string in query id.group_key_str: string in query id.proof_type: string in query id.asset_id: string in query	ID	object
leaf_key The asset key to query for. Nested REST Parameters leaf_key.script_key_bytes: string in query leaf_key.script_key_str: string in path leaf_key.op_str: string in query leaf_key.op.hash_str: string in path leaf_key.op.index: integer in path	AssetKey	object

Enums

universerpc.ProofType

Name	Number
PROOF_TYPE_UNSPECIFIED	0
PROOF_TYPE_ISSUANCE	1
PROOF_TYPE_TRANSFER	2