taprpc

type Addr struct {

	// The bech32 encoded Taproot Asset address.
	Encoded string `protobuf:"bytes,1,opt,name=encoded,proto3" json:"encoded,omitempty"`
	// The asset ID that uniquely identifies the asset. This can be all zeroes
	// for V2 addresses that have a group key set.
	AssetId []byte `protobuf:"bytes,2,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"`
	// The type of the asset.
	AssetType AssetType `protobuf:"varint,3,opt,name=asset_type,json=assetType,proto3,enum=taprpc.AssetType" json:"asset_type,omitempty"`
	// The total amount of the asset stored in this Taproot Asset UTXO. The
	// amount is allowed to be unset for V2 addresses, where the sender will
	// post a fragment containing the asset IDs and amounts to the proof
	// courier's auth mailbox.
	Amount uint64 `protobuf:"varint,4,opt,name=amount,proto3" json:"amount,omitempty"`
	// The group key of the asset group to receive assets for. If this field
	// is set, then any asset of the group can be sent to this address. Can only
	// be specified for V2 addresses. If this field is set, the asset_id
	// field must be empty.
	GroupKey []byte `protobuf:"bytes,5,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"`
	// The specific script key the asset must commit to in order to transfer
	// ownership to the creator of the address.
	ScriptKey []byte `protobuf:"bytes,6,opt,name=script_key,json=scriptKey,proto3" json:"script_key,omitempty"`
	// The internal key used for the on-chain output.
	InternalKey []byte `protobuf:"bytes,7,opt,name=internal_key,json=internalKey,proto3" json:"internal_key,omitempty"`
	// 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.
	TapscriptSibling []byte `protobuf:"bytes,8,opt,name=tapscript_sibling,json=tapscriptSibling,proto3" json:"tapscript_sibling,omitempty"`
	// 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.
	TaprootOutputKey []byte `protobuf:"bytes,9,opt,name=taproot_output_key,json=taprootOutputKey,proto3" json:"taproot_output_key,omitempty"`
	// The address of the proof courier service used in proof transfer. For V2
	// addresses the proof courier address is mandatory and must be a valid auth
	// mailbox address (authmailbox+universerpc://host:port).
	ProofCourierAddr string `protobuf:"bytes,10,opt,name=proof_courier_addr,json=proofCourierAddr,proto3" json:"proof_courier_addr,omitempty"`
	// The asset version of the address.
	AssetVersion AssetVersion `protobuf:"varint,11,opt,name=asset_version,json=assetVersion,proto3,enum=taprpc.AssetVersion" json:"asset_version,omitempty"`
	// The version of the address.
	AddressVersion AddrVersion `` /* 129-byte string literal not displayed */
	// contains filtered or unexported fields
}

type AddrEvent struct {

	// The time the event was created in unix timestamp seconds.
	CreationTimeUnixSeconds uint64 `` /* 135-byte string literal not displayed */
	// The address the event was created for.
	Addr *Addr `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
	// The current status of the event.
	Status AddrEventStatus `protobuf:"varint,3,opt,name=status,proto3,enum=taprpc.AddrEventStatus" json:"status,omitempty"`
	// The outpoint that contains the inbound asset transfer.
	Outpoint string `protobuf:"bytes,4,opt,name=outpoint,proto3" json:"outpoint,omitempty"`
	// The amount in satoshis that were transferred on chain along with the asset.
	// This amount is independent of the requested asset amount, which can be
	// looked up on the address.
	UtxoAmtSat uint64 `protobuf:"varint,5,opt,name=utxo_amt_sat,json=utxoAmtSat,proto3" json:"utxo_amt_sat,omitempty"`
	// The taproot sibling hash that was used to send to the Taproot output.
	TaprootSibling []byte `protobuf:"bytes,6,opt,name=taproot_sibling,json=taprootSibling,proto3" json:"taproot_sibling,omitempty"`
	// The height at which the on-chain output was confirmed. If this is zero, it
	// means the output is unconfirmed.
	ConfirmationHeight uint32 `protobuf:"varint,7,opt,name=confirmation_height,json=confirmationHeight,proto3" json:"confirmation_height,omitempty"`
	// Indicates whether a proof file can be found for the address' asset ID and
	// script key.
	HasProof bool `protobuf:"varint,8,opt,name=has_proof,json=hasProof,proto3" json:"has_proof,omitempty"`
	// contains filtered or unexported fields
}

type AddrEventStatus int32

type AddrReceivesRequest struct {

	// Filter receives by a specific address. Leave empty to get all receives.
	FilterAddr string `protobuf:"bytes,1,opt,name=filter_addr,json=filterAddr,proto3" json:"filter_addr,omitempty"`
	// Filter receives by a specific status. Leave empty to get all receives.
	FilterStatus AddrEventStatus `` /* 126-byte string literal not displayed */
	// Filter receives by creation time greater than or equal to this timestamp.
	// If not set, no start time filtering is applied.
	StartTimestamp uint64 `protobuf:"varint,3,opt,name=start_timestamp,json=startTimestamp,proto3" json:"start_timestamp,omitempty"`
	// Filter receives by creation time less than or equal to this timestamp.
	// If not set, no end time filtering is applied.
	EndTimestamp uint64 `protobuf:"varint,4,opt,name=end_timestamp,json=endTimestamp,proto3" json:"end_timestamp,omitempty"`
	// The number of events to skip.
	Offset int32 `protobuf:"varint,5,opt,name=offset,proto3" json:"offset,omitempty"`
	// The max number of events returned.
	Limit int32 `protobuf:"varint,6,opt,name=limit,proto3" json:"limit,omitempty"`
	// The direction of the page. Sorted by creation time.
	Direction SortDirection `protobuf:"varint,7,opt,name=direction,proto3,enum=taprpc.SortDirection" json:"direction,omitempty"`
	// contains filtered or unexported fields
}

type AddrReceivesResponse struct {

	// The events that match the filter criteria.
	Events []*AddrEvent `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
	// contains filtered or unexported fields
}

type AddrVersion int32

type AddressWithAmount struct {

	// The TAP address to send assets to.
	TapAddr string `protobuf:"bytes,1,opt,name=tap_addr,json=tapAddr,proto3" json:"tap_addr,omitempty"`
	// The amount of asset units to send to the address. This is only used for
	// re-usable V2 addresses that don't specify an amount in the address itself
	// and allow the sender to specify the amount on each send attempt. For V0
	// or V1 addresses, this can be left empty (zero) as the amount is taken
	// from the address itself.
	Amount uint64 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
	// contains filtered or unexported fields
}

type AnchorInfo struct {

	// The transaction that anchors the Taproot Asset commitment where the asset
	//
	//	resides.
	AnchorTx []byte `protobuf:"bytes,1,opt,name=anchor_tx,json=anchorTx,proto3" json:"anchor_tx,omitempty"`
	// The block hash the contains the anchor transaction above.
	AnchorBlockHash string `protobuf:"bytes,3,opt,name=anchor_block_hash,json=anchorBlockHash,proto3" json:"anchor_block_hash,omitempty"`
	// The outpoint (txid:vout) that stores the Taproot Asset commitment.
	AnchorOutpoint string `protobuf:"bytes,4,opt,name=anchor_outpoint,json=anchorOutpoint,proto3" json:"anchor_outpoint,omitempty"`
	// The raw internal key that was used to create the anchor Taproot output key.
	InternalKey []byte `protobuf:"bytes,5,opt,name=internal_key,json=internalKey,proto3" json:"internal_key,omitempty"`
	// The Taproot merkle root hash of the anchor output the asset was committed
	// to. If there is no Tapscript sibling, this is equal to the Taproot Asset
	// root commitment hash.
	MerkleRoot []byte `protobuf:"bytes,6,opt,name=merkle_root,json=merkleRoot,proto3" json:"merkle_root,omitempty"`
	// The serialized preimage of a Tapscript sibling, if there was one. If this
	// is empty, then the merkle_root hash is equal to the Taproot root hash of the
	// anchor output.
	TapscriptSibling []byte `protobuf:"bytes,7,opt,name=tapscript_sibling,json=tapscriptSibling,proto3" json:"tapscript_sibling,omitempty"`
	// The height of the block which contains the anchor transaction.
	BlockHeight uint32 `protobuf:"varint,8,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	// The UTC Unix timestamp of the block containing the anchor transaction.
	BlockTimestamp int64 `protobuf:"varint,9,opt,name=block_timestamp,json=blockTimestamp,proto3" json:"block_timestamp,omitempty"`
	// contains filtered or unexported fields
}

type AnchorTransaction struct {

	// The on-chain anchor transaction PSBT packet that was created by the
	// daemon.
	AnchorPsbt []byte `protobuf:"bytes,1,opt,name=anchor_psbt,json=anchorPsbt,proto3" json:"anchor_psbt,omitempty"`
	// The index of the (added) change output or -1 if no change was left over.
	ChangeOutputIndex int32 `protobuf:"varint,2,opt,name=change_output_index,json=changeOutputIndex,proto3" json:"change_output_index,omitempty"`
	// The total number of satoshis in on-chain fees paid by the anchor
	// transaction.
	ChainFeesSats int64 `protobuf:"varint,3,opt,name=chain_fees_sats,json=chainFeesSats,proto3" json:"chain_fees_sats,omitempty"`
	// The fee rate in sat/kWU that was targeted by the anchor transaction.
	TargetFeeRateSatKw int32 `protobuf:"varint,4,opt,name=target_fee_rate_sat_kw,json=targetFeeRateSatKw,proto3" json:"target_fee_rate_sat_kw,omitempty"`
	// The list of UTXO lock leases that were acquired for the inputs in the funded
	// PSBT packet from lnd. Only inputs added to the PSBT by this RPC are locked,
	// inputs that were already present in the PSBT are not locked.
	LndLockedUtxos []*OutPoint `protobuf:"bytes,5,rep,name=lnd_locked_utxos,json=lndLockedUtxos,proto3" json:"lnd_locked_utxos,omitempty"`
	// The final, signed anchor transaction that was broadcast to the network.
	FinalTx []byte `protobuf:"bytes,6,opt,name=final_tx,json=finalTx,proto3" json:"final_tx,omitempty"`
	// contains filtered or unexported fields
}

type Asset struct {

	// The version of the Taproot Asset.
	Version AssetVersion `protobuf:"varint,1,opt,name=version,proto3,enum=taprpc.AssetVersion" json:"version,omitempty"`
	// The base genesis information of an asset. This information never changes.
	AssetGenesis *GenesisInfo `protobuf:"bytes,2,opt,name=asset_genesis,json=assetGenesis,proto3" json:"asset_genesis,omitempty"`
	// The total amount of the asset stored in this Taproot Asset UTXO.
	Amount uint64 `protobuf:"varint,4,opt,name=amount,proto3" json:"amount,omitempty"`
	// An optional locktime, as with Bitcoin transactions.
	LockTime int32 `protobuf:"varint,5,opt,name=lock_time,json=lockTime,proto3" json:"lock_time,omitempty"`
	// An optional relative lock time, same as Bitcoin transactions.
	RelativeLockTime int32 `protobuf:"varint,6,opt,name=relative_lock_time,json=relativeLockTime,proto3" json:"relative_lock_time,omitempty"`
	// The version of the script, only version 0 is defined at present.
	ScriptVersion int32 `protobuf:"varint,7,opt,name=script_version,json=scriptVersion,proto3" json:"script_version,omitempty"`
	// The script key of the asset, which can be spent under Taproot semantics.
	ScriptKey []byte `protobuf:"bytes,9,opt,name=script_key,json=scriptKey,proto3" json:"script_key,omitempty"`
	// Indicates whether the script key is known to the wallet of the lnd node
	// connected to the Taproot Asset daemon.
	ScriptKeyIsLocal bool `protobuf:"varint,10,opt,name=script_key_is_local,json=scriptKeyIsLocal,proto3" json:"script_key_is_local,omitempty"`
	// The information related to the key group of an asset (if it exists).
	AssetGroup *AssetGroup `protobuf:"bytes,11,opt,name=asset_group,json=assetGroup,proto3" json:"asset_group,omitempty"`
	// Describes where in the chain the asset is currently anchored.
	ChainAnchor *AnchorInfo `protobuf:"bytes,12,opt,name=chain_anchor,json=chainAnchor,proto3" json:"chain_anchor,omitempty"`
	// The asset's previous witnesses, which either contain the spending
	// witness stack (usually a signature) or the split commitment witness
	// (which is used to prove the split commitment of a split asset).
	PrevWitnesses []*PrevWitness `protobuf:"bytes,13,rep,name=prev_witnesses,json=prevWitnesses,proto3" json:"prev_witnesses,omitempty"`
	// Indicates whether the asset has been spent.
	IsSpent bool `protobuf:"varint,14,opt,name=is_spent,json=isSpent,proto3" json:"is_spent,omitempty"`
	// If the asset has been leased, this is the owner (application ID) of the
	// lease.
	LeaseOwner []byte `protobuf:"bytes,15,opt,name=lease_owner,json=leaseOwner,proto3" json:"lease_owner,omitempty"`
	// If the asset has been leased, this is the expiry of the lease as a Unix
	// timestamp in seconds.
	LeaseExpiry int64 `protobuf:"varint,16,opt,name=lease_expiry,json=leaseExpiry,proto3" json:"lease_expiry,omitempty"`
	// Indicates whether this transfer was an asset burn. If true, the number of
	// assets in this output are destroyed and can no longer be spent.
	IsBurn bool `protobuf:"varint,17,opt,name=is_burn,json=isBurn,proto3" json:"is_burn,omitempty"`
	// Deprecated, use script_key_type instead!
	// Indicates whether this script key has either been derived by the local
	// wallet or was explicitly declared to be known by using the
	// DeclareScriptKey RPC. Knowing the key conceptually means the key belongs
	// to the local wallet or is at least known by a software that operates on
	// the local wallet. The flag is never serialized in proofs, so this is
	// never explicitly set for keys foreign to the local wallet. Therefore, if
	// this method returns true for a script key, it means the asset with the
	// script key will be shown in the wallet balance.
	ScriptKeyDeclaredKnown bool `` /* 133-byte string literal not displayed */
	// Deprecated, use script_key_type instead!
	// Indicates whether the script key is known to have a Tapscript spend path,
	// meaning that the Taproot merkle root tweak is not empty. This will only
	// ever be true if either script_key_is_local or script_key_internals_known
	// is true as well, since the presence of a Tapscript spend path cannot be
	// determined for script keys that aren't known to the wallet of the local
	// tapd node.
	ScriptKeyHasScriptPath bool `` /* 135-byte string literal not displayed */
	// This field defines a decimal display value that may be present. If this
	// field is null, it means the presence of a decimal display field is
	// unknown in the current context.
	DecimalDisplay *DecimalDisplay `protobuf:"bytes,20,opt,name=decimal_display,json=decimalDisplay,proto3" json:"decimal_display,omitempty"`
	// 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 ScriptKeyType `` /* 130-byte string literal not displayed */
	// contains filtered or unexported fields
}

type AssetBalance struct {

	// The base genesis information of an asset. This information never changes.
	AssetGenesis *GenesisInfo `protobuf:"bytes,1,opt,name=asset_genesis,json=assetGenesis,proto3" json:"asset_genesis,omitempty"`
	// The balance of the asset owned by the target daemon.
	Balance uint64 `protobuf:"varint,3,opt,name=balance,proto3" json:"balance,omitempty"`
	// The group key of the asset (if it belongs to a group).
	GroupKey []byte `protobuf:"bytes,4,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"`
	// contains filtered or unexported fields
}

type AssetBurn struct {

	// A note that may contain user defined metadata related to this burn.
	Note string `protobuf:"bytes,1,opt,name=note,proto3" json:"note,omitempty"`
	// The asset id of the burnt asset.
	AssetId []byte `protobuf:"bytes,2,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"`
	// The tweaked group key of the group this asset belongs to.
	TweakedGroupKey []byte `protobuf:"bytes,3,opt,name=tweaked_group_key,json=tweakedGroupKey,proto3" json:"tweaked_group_key,omitempty"`
	// The amount of burnt assets.
	Amount uint64 `protobuf:"varint,4,opt,name=amount,proto3" json:"amount,omitempty"`
	// The txid of the transaction that the burn was anchored to.
	AnchorTxid []byte `protobuf:"bytes,5,opt,name=anchor_txid,json=anchorTxid,proto3" json:"anchor_txid,omitempty"`
	// The type of the burnt asset.
	AssetType AssetType `protobuf:"varint,6,opt,name=asset_type,json=assetType,proto3,enum=taprpc.AssetType" json:"asset_type,omitempty"`
	// contains filtered or unexported fields
}

type AssetGroup struct {

	// The raw group key which is a normal public key.
	RawGroupKey []byte `protobuf:"bytes,1,opt,name=raw_group_key,json=rawGroupKey,proto3" json:"raw_group_key,omitempty"`
	// The tweaked group key, which is derived based on the genesis point and also
	// asset type.
	TweakedGroupKey []byte `protobuf:"bytes,2,opt,name=tweaked_group_key,json=tweakedGroupKey,proto3" json:"tweaked_group_key,omitempty"`
	// A witness that authorizes a specific asset to be part of the asset group
	// specified by the above key.
	AssetWitness []byte `protobuf:"bytes,3,opt,name=asset_witness,json=assetWitness,proto3" json:"asset_witness,omitempty"`
	// The root hash of a tapscript tree, which enables future issuance authorized
	// with a script witness.
	TapscriptRoot []byte `protobuf:"bytes,4,opt,name=tapscript_root,json=tapscriptRoot,proto3" json:"tapscript_root,omitempty"`
	// contains filtered or unexported fields
}

type AssetGroupBalance struct {

	// The group key or nil aggregating assets that don't have a group.
	GroupKey []byte `protobuf:"bytes,1,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"`
	// The total balance of the assets in the group.
	Balance uint64 `protobuf:"varint,2,opt,name=balance,proto3" json:"balance,omitempty"`
	// contains filtered or unexported fields
}

type AssetHumanReadable struct {

	// The ID of the asset.
	Id []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// The amount of the asset.
	Amount uint64 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
	// An optional locktime, as with Bitcoin transactions.
	LockTime int32 `protobuf:"varint,3,opt,name=lock_time,json=lockTime,proto3" json:"lock_time,omitempty"`
	// An optional relative locktime, as with Bitcoin transactions.
	RelativeLockTime int32 `protobuf:"varint,4,opt,name=relative_lock_time,json=relativeLockTime,proto3" json:"relative_lock_time,omitempty"`
	// The name of the asset.
	Tag string `protobuf:"bytes,5,opt,name=tag,proto3" json:"tag,omitempty"`
	// The metadata hash of the asset.
	MetaHash []byte `protobuf:"bytes,6,opt,name=meta_hash,json=metaHash,proto3" json:"meta_hash,omitempty"`
	// The type of the asset.
	Type AssetType `protobuf:"varint,7,opt,name=type,proto3,enum=taprpc.AssetType" json:"type,omitempty"`
	// The version of the asset.
	Version AssetVersion `protobuf:"varint,8,opt,name=version,proto3,enum=taprpc.AssetVersion" json:"version,omitempty"`
	// contains filtered or unexported fields
}

type AssetMeta struct {

	// 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.
	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	// The type of the asset meta data.
	Type AssetMetaType `protobuf:"varint,2,opt,name=type,proto3,enum=taprpc.AssetMetaType" json:"type,omitempty"`
	// The hash of the meta. This is the hash of the TLV serialization of the meta
	// itself.
	MetaHash []byte `protobuf:"bytes,3,opt,name=meta_hash,json=metaHash,proto3" json:"meta_hash,omitempty"`
	// contains filtered or unexported fields
}

type AssetMetaType int32

type AssetOutPoint struct {

	// The outpoint of the asset anchor, represented as a string in the
	// format "<txid>:<vout>". The <txid> is the transaction ID of the UTXO,
	// hex-encoded and byte-reversed (i.e., the internal little-endian
	// 32-byte value is reversed to big-endian hex format) to match standard
	// Bitcoin RPC and UI conventions.
	AnchorOutPoint string `protobuf:"bytes,1,opt,name=anchor_out_point,json=anchorOutPoint,proto3" json:"anchor_out_point,omitempty"`
	// The asset ID of the asset anchored at the outpoint.
	AssetId []byte `protobuf:"bytes,2,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"`
	// The script key of the asset. This is the taproot output key that the
	// asset is locked to.
	ScriptKey []byte `protobuf:"bytes,3,opt,name=script_key,json=scriptKey,proto3" json:"script_key,omitempty"`
	// contains filtered or unexported fields
}

type AssetSpecifier struct {

	// Types that are valid to be assigned to Id:
	//
	//	*AssetSpecifier_AssetId
	//	*AssetSpecifier_AssetIdStr
	//	*AssetSpecifier_GroupKey
	//	*AssetSpecifier_GroupKeyStr
	Id isAssetSpecifier_Id `protobuf_oneof:"id"`
	// contains filtered or unexported fields
}

type AssetSpecifier_AssetId struct {
	// The 32-byte asset ID specified as raw bytes (gRPC only).
	AssetId []byte `protobuf:"bytes,1,opt,name=asset_id,json=assetId,proto3,oneof"`
}

type AssetSpecifier_AssetIdStr struct {
	// The 32-byte asset ID encoded as a hex string (use this for REST).
	AssetIdStr string `protobuf:"bytes,2,opt,name=asset_id_str,json=assetIdStr,proto3,oneof"`
}

type AssetSpecifier_GroupKey struct {
	// The 32-byte asset group key specified as raw bytes (gRPC only).
	GroupKey []byte `protobuf:"bytes,3,opt,name=group_key,json=groupKey,proto3,oneof"`
}

type AssetSpecifier_GroupKeyStr struct {
	// The 32-byte asset group key encoded as hex string (use this for
	// REST).
	GroupKeyStr string `protobuf:"bytes,4,opt,name=group_key_str,json=groupKeyStr,proto3,oneof"`
}

type AssetTransfer struct {

	// The timestamp of the transfer in UTC Unix time seconds.
	TransferTimestamp int64 `protobuf:"varint,1,opt,name=transfer_timestamp,json=transferTimestamp,proto3" json:"transfer_timestamp,omitempty"`
	// The new transaction that commits to the set of Taproot Assets found at
	// the above new anchor point. Note that this is in raw byte format, not
	// the reversed hex string format that is used for displayed txids. When
	// listing assets on the CLI we purposefully use the display format so it
	// is easier to copy and paste into other tools.
	AnchorTxHash []byte `protobuf:"bytes,2,opt,name=anchor_tx_hash,json=anchorTxHash,proto3" json:"anchor_tx_hash,omitempty"`
	// The height hint of the anchor transaction. This is the height at which
	// the anchor transaction was published, so the actual inclusion height
	// will be greater than this value.
	AnchorTxHeightHint uint32 `protobuf:"varint,3,opt,name=anchor_tx_height_hint,json=anchorTxHeightHint,proto3" json:"anchor_tx_height_hint,omitempty"`
	// The total fees paid by the anchor transaction in satoshis.
	AnchorTxChainFees int64 `protobuf:"varint,4,opt,name=anchor_tx_chain_fees,json=anchorTxChainFees,proto3" json:"anchor_tx_chain_fees,omitempty"`
	// Describes the set of spent assets.
	Inputs []*TransferInput `protobuf:"bytes,5,rep,name=inputs,proto3" json:"inputs,omitempty"`
	// Describes the set of newly created asset outputs.
	Outputs []*TransferOutput `protobuf:"bytes,6,rep,name=outputs,proto3" json:"outputs,omitempty"`
	// The block hash of the blockchain block that contains the anchor
	// transaction. If this value is unset, the anchor transaction is
	// unconfirmed.
	AnchorTxBlockHash *ChainHash `protobuf:"bytes,7,opt,name=anchor_tx_block_hash,json=anchorTxBlockHash,proto3" json:"anchor_tx_block_hash,omitempty"`
	// The block height of the blockchain block that contains the anchor
	// transaction. If the anchor transaction is still unconfirmed, this value
	// will be 0.
	AnchorTxBlockHeight uint32 `protobuf:"varint,8,opt,name=anchor_tx_block_height,json=anchorTxBlockHeight,proto3" json:"anchor_tx_block_height,omitempty"`
	// An optional short label for the transfer. This label can be used to track
	// the progress of the transfer via the logs or an event subscription.
	// Multiple transfers can share the same label.
	Label string `protobuf:"bytes,9,opt,name=label,proto3" json:"label,omitempty"`
	// The L1 transaction that anchors the Taproot Asset commitment where the
	// asset resides.
	AnchorTx []byte `protobuf:"bytes,10,opt,name=anchor_tx,json=anchorTx,proto3" json:"anchor_tx,omitempty"`
	// contains filtered or unexported fields
}

type AssetType int32

type AssetVersion int32

type BakeMacaroonRequest struct {

	// The list of permissions the new macaroon should grant.
	Permissions []*MacaroonPermission `protobuf:"bytes,1,rep,name=permissions,proto3" json:"permissions,omitempty"`
	// The root key ID used to create the macaroon, must be a non-negative integer.
	RootKeyId uint64 `protobuf:"varint,2,opt,name=root_key_id,json=rootKeyId,proto3" json:"root_key_id,omitempty"`
	// Informs the RPC on whether to allow external permissions that tapd is not
	// aware of.
	AllowExternalPermissions bool `` /* 136-byte string literal not displayed */
	// contains filtered or unexported fields
}

type BakeMacaroonResponse struct {

	// The hex encoded macaroon, serialized in binary format.
	Macaroon string `protobuf:"bytes,1,opt,name=macaroon,proto3" json:"macaroon,omitempty"`
	// contains filtered or unexported fields
}

type BurnAssetRequest struct {

	// Deprecated: Use asset_specifier instead.
	//
	// Types that are valid to be assigned to Asset:
	//
	//	*BurnAssetRequest_AssetId
	//	*BurnAssetRequest_AssetIdStr
	Asset isBurnAssetRequest_Asset `protobuf_oneof:"asset"`
	// The number of asset units to burn. This must be greater than zero.
	AmountToBurn uint64 `protobuf:"varint,3,opt,name=amount_to_burn,json=amountToBurn,proto3" json:"amount_to_burn,omitempty"`
	// A safety check to ensure the user is aware of the destructive nature of
	// the burn. This needs to be set to the value "assets will be destroyed"
	// for the burn to succeed.
	ConfirmationText string `protobuf:"bytes,4,opt,name=confirmation_text,json=confirmationText,proto3" json:"confirmation_text,omitempty"`
	// A note that may contain user defined metadata related to this burn.
	Note string `protobuf:"bytes,5,opt,name=note,proto3" json:"note,omitempty"`
	// The asset specifier identifying which asset to burn. Supports both
	// asset ID and group key. This field supersedes the deprecated
	// asset_id/asset_id_str fields above.
	AssetSpecifier *AssetSpecifier `protobuf:"bytes,6,opt,name=asset_specifier,json=assetSpecifier,proto3" json:"asset_specifier,omitempty"`
	// contains filtered or unexported fields
}

type BurnAssetRequest_AssetId struct {
	// Deprecated, the asset ID of the asset to burn units of.
	// Use asset_specifier instead.
	//
	// Deprecated: Marked as deprecated in taprootassets.proto.
	AssetId []byte `protobuf:"bytes,1,opt,name=asset_id,json=assetId,proto3,oneof"`
}

type BurnAssetRequest_AssetIdStr struct {
	// Deprecated, the hex encoded asset ID of the asset to burn units of.
	// Use asset_specifier instead.
	//
	// Deprecated: Marked as deprecated in taprootassets.proto.
	AssetIdStr string `protobuf:"bytes,2,opt,name=asset_id_str,json=assetIdStr,proto3,oneof"`
}

type BurnAssetResponse struct {

	// The asset transfer that contains the asset burn as an output.
	BurnTransfer *AssetTransfer `protobuf:"bytes,1,opt,name=burn_transfer,json=burnTransfer,proto3" json:"burn_transfer,omitempty"`
	// Deprecated: Use burn_proofs instead.
	//
	// Deprecated: Marked as deprecated in taprootassets.proto.
	BurnProof *DecodedProof `protobuf:"bytes,2,opt,name=burn_proof,json=burnProof,proto3" json:"burn_proof,omitempty"`
	// The burn transition proofs for the asset burn outputs. May contain
	// more than one entry when burning by group key across multiple
	// issuances.
	BurnProofs []*DecodedProof `protobuf:"bytes,3,rep,name=burn_proofs,json=burnProofs,proto3" json:"burn_proofs,omitempty"`
	// contains filtered or unexported fields
}

type ChainHash struct {

	// The raw hash value in byte format.
	//
	// This format is optimized for programmatic use, particularly for Go
	// developers, enabling easy integration with other RPC calls or binary
	// operations.
	Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	// The byte-reversed hash value as a hexadecimal string.
	//
	// This format is intended for human interaction, making it easy to copy,
	// paste, and use in contexts like command-line arguments or configuration
	// files.
	HashStr string `protobuf:"bytes,2,opt,name=hash_str,json=hashStr,proto3" json:"hash_str,omitempty"`
	// contains filtered or unexported fields
}

type DebugLevelRequest struct {

	// If true, all the valid debug sub-systems will be returned.
	Show bool `protobuf:"varint,1,opt,name=show,proto3" json:"show,omitempty"`
	// If set, the debug level for the sub-system will be set to this value.
	// Can be one of: "trace", "debug", "info", "warn", "error", "critical",
	// "off", to set a global level, optionally followed by a comma-separated
	// list of sub-systems to set the level for. For example:
	// "debug,TADB=info,UNIV=warn".
	LevelSpec string `protobuf:"bytes,2,opt,name=level_spec,json=levelSpec,proto3" json:"level_spec,omitempty"`
	// contains filtered or unexported fields
}

type DebugLevelResponse struct {

	// The list of available logging sub-systems that can be set to a specific
	// debug level.
	SubSystems string `protobuf:"bytes,1,opt,name=sub_systems,json=subSystems,proto3" json:"sub_systems,omitempty"`
	// contains filtered or unexported fields
}

type DecimalDisplay struct {

	// Decimal display dictates the number of decimal places to shift the amount to
	// the left converting from Taproot Asset integer representation to a
	// UX-recognizable fractional quantity.
	//
	// For example, if the decimal_display value is 2 and there's 100 of those
	// assets, then a wallet would display the amount as "1.00". This field is
	// intended as information for wallets that display balances and has no impact
	// on the behavior of the daemon or any other part of the protocol. This value
	// is encoded in the MetaData field as a JSON field, therefore it is only
	// compatible with assets that have a JSON MetaData field.
	DecimalDisplay uint32 `protobuf:"varint,1,opt,name=decimal_display,json=decimalDisplay,proto3" json:"decimal_display,omitempty"`
	// contains filtered or unexported fields
}

type DecodeAddrRequest struct {

	// The bech32 encoded Taproot Asset address to decode.
	Addr string `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	// contains filtered or unexported fields
}

type DecodeProofRequest struct {

	// The raw proof bytes to decode. This can be a full proof file or a single
	// mint/transition proof. If it is a full proof file, the proof_at_depth
	// field will be used to determine which individual proof within the file to
	// decode.
	RawProof []byte `protobuf:"bytes,1,opt,name=raw_proof,json=rawProof,proto3" json:"raw_proof,omitempty"`
	// The index depth of the decoded proof, with 0 being the latest proof. This
	// is ignored if the raw_proof is a single mint/transition proof and not a
	// proof file.
	ProofAtDepth uint32 `protobuf:"varint,2,opt,name=proof_at_depth,json=proofAtDepth,proto3" json:"proof_at_depth,omitempty"`
	// An option to include previous witnesses in decoding.
	WithPrevWitnesses bool `protobuf:"varint,3,opt,name=with_prev_witnesses,json=withPrevWitnesses,proto3" json:"with_prev_witnesses,omitempty"`
	// An option to attempt to retrieve the meta data associated with the proof.
	WithMetaReveal bool `protobuf:"varint,4,opt,name=with_meta_reveal,json=withMetaReveal,proto3" json:"with_meta_reveal,omitempty"`
	// contains filtered or unexported fields
}

type DecodeProofResponse struct {

	// The decoded, more human-readable proof.
	DecodedProof *DecodedProof `protobuf:"bytes,1,opt,name=decoded_proof,json=decodedProof,proto3" json:"decoded_proof,omitempty"`
	// contains filtered or unexported fields
}

type DecodedProof struct {

	// The index depth of the decoded proof, with 0 being the latest proof.
	ProofAtDepth uint32 `protobuf:"varint,1,opt,name=proof_at_depth,json=proofAtDepth,proto3" json:"proof_at_depth,omitempty"`
	// The total number of proofs contained in the decoded proof file (this will
	// always be 1 if a single mint/transition proof was given as the raw_proof
	// instead of a file).
	NumberOfProofs uint32 `protobuf:"varint,2,opt,name=number_of_proofs,json=numberOfProofs,proto3" json:"number_of_proofs,omitempty"`
	// The asset referenced in the proof.
	Asset *Asset `protobuf:"bytes,3,opt,name=asset,proto3" json:"asset,omitempty"`
	// The reveal meta data associated with the proof, if available.
	MetaReveal *AssetMeta `protobuf:"bytes,4,opt,name=meta_reveal,json=metaReveal,proto3" json:"meta_reveal,omitempty"`
	// The merkle proof for AnchorTx used to prove its
	// inclusion within BlockHeader.
	TxMerkleProof []byte `protobuf:"bytes,5,opt,name=tx_merkle_proof,json=txMerkleProof,proto3" json:"tx_merkle_proof,omitempty"`
	// The TaprootProof proving the new inclusion of the
	// resulting asset within AnchorTx.
	InclusionProof []byte `protobuf:"bytes,6,opt,name=inclusion_proof,json=inclusionProof,proto3" json:"inclusion_proof,omitempty"`
	// The set of TaprootProofs proving the exclusion of
	// the resulting asset from all other Taproot outputs within AnchorTx.
	ExclusionProofs [][]byte `protobuf:"bytes,7,rep,name=exclusion_proofs,json=exclusionProofs,proto3" json:"exclusion_proofs,omitempty"`
	// An optional TaprootProof needed if this asset is
	// the result of a split. SplitRootProof proves inclusion of the root
	// asset of the split.
	SplitRootProof []byte `protobuf:"bytes,8,opt,name=split_root_proof,json=splitRootProof,proto3" json:"split_root_proof,omitempty"`
	// The number of additional nested full proofs for any inputs found within
	// the resulting asset.
	NumAdditionalInputs uint32 `protobuf:"varint,9,opt,name=num_additional_inputs,json=numAdditionalInputs,proto3" json:"num_additional_inputs,omitempty"`
	// ChallengeWitness is an optional virtual transaction witness that serves
	// as an ownership proof for the asset. If this is non-nil, then it is a
	// valid transfer witness for a 1-input, 1-output virtual transaction that
	// spends the asset in this proof and sends it to the NUMS key, to prove
	// that the creator of the proof is able to produce a valid signature to
	// spend the asset.
	ChallengeWitness [][]byte `protobuf:"bytes,10,rep,name=challenge_witness,json=challengeWitness,proto3" json:"challenge_witness,omitempty"`
	// Indicates whether the state transition this proof represents is a burn,
	// meaning that the assets were provably destroyed and can no longer be
	// spent.
	IsBurn bool `protobuf:"varint,11,opt,name=is_burn,json=isBurn,proto3" json:"is_burn,omitempty"`
	// GenesisReveal is an optional field that is the Genesis information for
	// the asset. This is required for minting proofs.
	GenesisReveal *GenesisReveal `protobuf:"bytes,12,opt,name=genesis_reveal,json=genesisReveal,proto3" json:"genesis_reveal,omitempty"`
	// GroupKeyReveal is an optional field that includes the information needed
	// to derive the tweaked group key.
	GroupKeyReveal *GroupKeyReveal `protobuf:"bytes,13,opt,name=group_key_reveal,json=groupKeyReveal,proto3" json:"group_key_reveal,omitempty"`
	// AltLeaves represent data used to construct an Asset commitment, that
	// will be inserted in the input anchor Tap commitment. These data-carrying
	// leaves are used for a purpose distinct from representing individual
	// individual Taproot Assets.
	AltLeaves []byte `protobuf:"bytes,14,opt,name=alt_leaves,json=altLeaves,proto3" json:"alt_leaves,omitempty"`
	// contains filtered or unexported fields
}

type ExportProofRequest struct {

	// The asset ID of the asset to export the proof for.
	AssetId []byte `protobuf:"bytes,1,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"`
	// The script key of the asset to export the proof for.
	ScriptKey []byte `protobuf:"bytes,2,opt,name=script_key,json=scriptKey,proto3" json:"script_key,omitempty"`
	// The on-chain outpoint of the asset to export the proof for.
	Outpoint *OutPoint `protobuf:"bytes,3,opt,name=outpoint,proto3" json:"outpoint,omitempty"`
	// contains filtered or unexported fields
}

type ExternalKey struct {

	// This field specifies the extended public key derived at depth 3 of the
	// BIP-86 hierarchy (e.g., m/86'/0'/0'). This key serves as the parent key for
	// deriving child public keys and addresses.
	Xpub string `protobuf:"bytes,1,opt,name=xpub,proto3" json:"xpub,omitempty"`
	// This field specifies the fingerprint of the master key, derived from the
	// first 4 bytes of the hash160 of the master public key. It is used to
	// identify the master key in BIP-86 derivation schemes.
	MasterFingerprint []byte `protobuf:"bytes,2,opt,name=master_fingerprint,json=masterFingerprint,proto3" json:"master_fingerprint,omitempty"`
	// This field specifies the extended BIP-86 derivation path used to derive a
	// child key from the XPub. Starting from the base path of the XPub
	// (e.g., m/86'/0'/0'), this path must contain exactly 5 components in total
	// (e.g., m/86'/0'/0'/0/0), with the additional components defining specific
	// child keys, such as individual addresses.
	DerivationPath string `protobuf:"bytes,3,opt,name=derivation_path,json=derivationPath,proto3" json:"derivation_path,omitempty"`
	// contains filtered or unexported fields
}

type FetchAssetMetaRequest struct {

	// Types that are valid to be assigned to Asset:
	//
	//	*FetchAssetMetaRequest_AssetId
	//	*FetchAssetMetaRequest_MetaHash
	//	*FetchAssetMetaRequest_AssetIdStr
	//	*FetchAssetMetaRequest_MetaHashStr
	Asset isFetchAssetMetaRequest_Asset `protobuf_oneof:"asset"`
	// contains filtered or unexported fields
}

type FetchAssetMetaRequest_AssetId struct {
	// The asset ID of the asset to fetch the meta for.
	AssetId []byte `protobuf:"bytes,1,opt,name=asset_id,json=assetId,proto3,oneof"`
}

type FetchAssetMetaRequest_AssetIdStr struct {
	// The hex encoded asset ID of the asset to fetch the meta for.
	AssetIdStr string `protobuf:"bytes,3,opt,name=asset_id_str,json=assetIdStr,proto3,oneof"`
}

type FetchAssetMetaRequest_MetaHash struct {
	// The 32-byte meta hash of the asset meta.
	MetaHash []byte `protobuf:"bytes,2,opt,name=meta_hash,json=metaHash,proto3,oneof"`
}

type FetchAssetMetaRequest_MetaHashStr struct {
	// The hex encoded meta hash of the asset meta.
	MetaHashStr string `protobuf:"bytes,4,opt,name=meta_hash_str,json=metaHashStr,proto3,oneof"`
}

type FetchAssetMetaResponse struct {

	// 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.
	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	// The type of the asset meta data.
	Type AssetMetaType `protobuf:"varint,2,opt,name=type,proto3,enum=taprpc.AssetMetaType" json:"type,omitempty"`
	// The hash of the meta. This is the hash of the TLV serialization of the meta
	// itself.
	MetaHash []byte `protobuf:"bytes,3,opt,name=meta_hash,json=metaHash,proto3" json:"meta_hash,omitempty"`
	// A map of unknown odd TLV types that were encountered during asset meta data
	// decoding.
	UnknownOddTypes map[uint64][]byte `` /* 183-byte string literal not displayed */
	// The decimal display value of the asset. This is used to determine the number
	// of decimal places to display when presenting the asset amount to the user.
	DecimalDisplay uint32 `protobuf:"varint,5,opt,name=decimal_display,json=decimalDisplay,proto3" json:"decimal_display,omitempty"`
	// Boolean flag indicating whether the asset-group issuer publishes
	// universe-supply commitments to the canonical universe set.
	UniverseCommitments bool `protobuf:"varint,6,opt,name=universe_commitments,json=universeCommitments,proto3" json:"universe_commitments,omitempty"`
	// List of canonical universe URLs where the asset-group issuer publishes
	// asset-related proofs.
	CanonicalUniverseUrls []string `` /* 126-byte string literal not displayed */
	// The public key that is used to verify universe supply commitment related
	// on-chain outputs and proofs.
	DelegationKey []byte `protobuf:"bytes,8,opt,name=delegation_key,json=delegationKey,proto3" json:"delegation_key,omitempty"`
	// contains filtered or unexported fields
}

type FetchAssetRequest struct {

	// The asset specifier (asset ID or group key) identifying the asset(s) to
	// fetch. At least one of asset_id or group_key must be specified.
	AssetSpecifier *AssetSpecifier `protobuf:"bytes,1,opt,name=asset_specifier,json=assetSpecifier,proto3" json:"asset_specifier,omitempty"`
	// Whether to include each asset's witness in the response. The witness
	// either contains the spending signatures or the split commitment witness,
	// which can both be large and usually aren't very useful on the command
	// line, so are omitted by default.
	WithWitness bool `protobuf:"varint,2,opt,name=with_witness,json=withWitness,proto3" json:"with_witness,omitempty"`
	// Include assets that are marked as spent (which is always true for burn
	// or tombstone assets).
	IncludeSpent bool `protobuf:"varint,3,opt,name=include_spent,json=includeSpent,proto3" json:"include_spent,omitempty"`
	// Include assets that are leased (locked/reserved) by the daemon for a
	// pending transfer. Leased assets cannot be used by the daemon until the
	// pending transfer is confirmed or the lease expires.
	IncludeLeased bool `protobuf:"varint,4,opt,name=include_leased,json=includeLeased,proto3" json:"include_leased,omitempty"`
	// List assets that aren't confirmed yet. Only freshly minted assets will
	// show in the asset list with a block height of 0. All other forms of
	// unconfirmed assets will not appear in the list until the transaction is
	// confirmed (check either transfers or receives for unconfirmed outbound or
	// inbound assets).
	IncludeUnconfirmedMints bool `` /* 133-byte string literal not displayed */
	// The script key type to filter the assets by. If not set, only assets with
	// a BIP-0086 script key will be returned (which is the equivalent of
	// setting script_key_type.explicit_type = SCRIPT_KEY_BIP86). If the type
	// is set to SCRIPT_KEY_BURN or SCRIPT_KEY_TOMBSTONE the include_spent flag
	// will automatically be set to true, because assets of that type are always
	// marked as spent.
	ScriptKeyType *ScriptKeyTypeQuery `protobuf:"bytes,6,opt,name=script_key_type,json=scriptKeyType,proto3" json:"script_key_type,omitempty"`
	// contains filtered or unexported fields
}