type Address struct {
	// Encoded is the bech32m encoded Taproot Asset address string.
	// This is the canonical representation used for sharing with senders.
	Encoded string

	// AssetRef is the SDK's user-facing asset identifier for the address.
	AssetRef AssetRef

	// AssetType indicates whether this is a normal or collectible asset.
	AssetType AssetType

	// Amount is the number of asset units expected at this address.
	// For V2 addresses, this may be zero to allow sender-chosen amounts.
	Amount uint64

	// ScriptKey is the Taproot output key the asset will be locked to.
	ScriptKey PubKey

	// InternalKey is the internal key for the on-chain anchor output.
	InternalKey PubKey

	// TapscriptSibling is the optional serialized tapscript sibling preimage.
	// Used when additional script paths exist alongside the asset commitment.
	TapscriptSibling []byte

	// TaprootOutputKey is the tweaked key for the on-chain Bitcoin output.
	TaprootOutputKey XOnlyPubKey

	// ProofCourierAddr is the address of the proof courier service.
	// For V2 addresses, this is mandatory and must be an auth mailbox URL.
	ProofCourierAddr string

	// AssetVersion is the asset version for transfers to this address.
	AssetVersion AssetVersion

	// AddressVersion is the address format version (V0, V1, or V2).
	AddressVersion AddressVersion
}

type AddressEvent struct {
	// CreationTime is the Unix timestamp when the event was created.
	CreationTime uint64

	// Address is the address that received the transfer.
	Address *Address

	// Status is the current status of the incoming transfer.
	Status AddressEventStatus

	// Outpoint is the Bitcoin outpoint containing the inbound transfer.
	// Format: "txid:index"
	Outpoint string

	// UTXOAmountSat is the amount in satoshis transferred on-chain.
	// This is independent of the asset amount.
	UTXOAmountSat uint64

	// TaprootSibling is the taproot sibling hash used for the output.
	TaprootSibling []byte

	// ConfirmationHeight is the block height where the output was confirmed.
	// Zero means the output is unconfirmed.
	ConfirmationHeight uint32

	// HasProof indicates whether a proof file exists for this transfer.
	HasProof bool
}

type AddressEventStatus uint8

type AddressQuery struct {
	// CreatedAfter filters addresses created after this Unix timestamp.
	// Zero means no lower bound.
	CreatedAfter int64

	// CreatedBefore filters addresses created before this Unix timestamp.
	// Zero means no upper bound.
	CreatedBefore int64

	// Limit is the maximum number of addresses to return.
	// Zero means use server default.
	Limit int32

	// Offset is the number of addresses to skip for pagination.
	Offset int32
}

type AddressReceivesQuery struct {
	// FilterAddr filters events for a specific address string.
	// Empty means return events for all addresses.
	FilterAddr string

	// FilterStatus filters events by status.
	// Zero (Unknown) means return all statuses.
	FilterStatus AddressEventStatus

	// StartTimestamp filters events created at or after this Unix timestamp.
	// Zero means no lower bound.
	StartTimestamp uint64

	// EndTimestamp filters events created at or before this Unix timestamp.
	// Zero means no upper bound.
	EndTimestamp uint64

	// Offset is the number of events to skip for pagination.
	Offset int32

	// Limit is the maximum number of events to return.
	// Zero means use server default.
	Limit int32

	// Direction specifies sort order by creation time.
	Direction SortDirection
}

type AddressVersion uint8

type AltLeaf struct {
	// Value is the raw bytes of the leaf.
	Value []byte
}

type AnchorChangeOutput struct {
	// Mode selects the change-output behavior.
	Mode AnchorChangeOutputMode

	// ExistingOutputIndex is the output index to use when Mode is
	// AnchorChangeOutputExisting.
	ExistingOutputIndex int32
}

type AnchorChangeOutputMode uint8

type AnchorConfirmation struct {
	// BlockHeight is the height of Block in the chain.
	BlockHeight uint32

	// Block is the serialized Bitcoin block containing the anchor
	// transaction.
	Block []byte
}

type AnchorFee struct {
	// Mode selects the fee behavior.
	Mode AnchorFeeMode

	// FeeRate is used when Mode is AnchorFeeSatPerVByte.
	FeeRate FeeRate

	// TargetConf is used when Mode is AnchorFeeTargetConf.
	TargetConf uint32
}

type AnchorFeeMode uint8

type AnchorFundingPlan struct {
	// ChangeOutput selects how the backend handles anchor change.
	ChangeOutput AnchorChangeOutput

	// Fee selects the anchor fee strategy.
	Fee AnchorFee

	// CustomLockID optionally identifies lnd UTXO locks created while funding.
	CustomLockID []byte

	// LockExpirationSeconds optionally overrides the backend lock duration.
	LockExpirationSeconds uint64

	// SkipFunding skips backend PSBT funding and only commits asset outputs.
	SkipFunding bool
}

type AnchorSigner func(ctx context.Context, anchorPsbt []byte) ([]byte, error)

type AnchorTransaction struct {
	// AnchorPsbt is the anchor transaction PSBT packet.
	AnchorPsbt []byte

	// ChangeOutputIndex is the index of the change output, or -1 if
	// no change was produced.
	ChangeOutputIndex int32

	// ChainFeesSats is the total on-chain fees paid in satoshis.
	ChainFeesSats int64

	// TargetFeeRate is the target fee rate.
	TargetFeeRate FeeRate

	// LndLockedUtxos lists the UTXO lock leases acquired from lnd.
	LndLockedUtxos []Outpoint

	// FinalTx is the signed anchor transaction that was broadcast.
	FinalTx []byte
}

type Asset struct {
	// AssetRef is the stable SDK identifier for this asset.
	AssetRef AssetRef

	// Type is the asset type.
	Type AssetType

	// Name is the human-readable asset name.
	Name string

	// MetaHash is the asset metadata hash.
	MetaHash Hash

	// Amount is the sum of wallet rows returned by the ListAssets request. With
	// the default request this is the wallet-known confirmed, unspent, unleased
	// amount. For grouped fungibles, this may be larger than the amount a
	// single-tranche builder path can spend in one transfer.
	Amount uint64

	// CollectionRef identifies the collection this NFT belongs to. It is nil
	// for fungible assets and standalone NFTs.
	CollectionRef *AssetRef
}

type AssetFederationSyncConfig struct {
	// ID is the universe ID this config applies to.
	ID UniverseID

	// AllowSyncInsert enables federation insert for this asset.
	AllowSyncInsert bool

	// AllowSyncExport enables federation export for this asset.
	AllowSyncExport bool
}

type AssetGroupMember struct {
	// AssetRef is the SDK identifier for the containing group.
	AssetRef AssetRef

	// IssuanceID is the 32-byte protocol-level identifier of this issuance.
	IssuanceID AssetID

	// Amount is the asset amount.
	Amount uint64

	// LockTime is the optional absolute locktime.
	LockTime int32

	// RelativeLockTime is the optional relative locktime.
	RelativeLockTime int32

	// Tag is the name of the asset.
	Tag string

	// MetaHash is the metadata hash.
	MetaHash Hash

	// Type is the asset type.
	Type AssetType

	// Version is the asset version.
	Version uint8
}

type AssetGroupRecord struct {
	// AssetRef is the SDK identifier for this group. Callers that need
	// the raw group public key can extract it via AssetRef.GroupKey().
	AssetRef AssetRef

	// Members are the concrete issuances or NFT items in this protocol group.
	Members []*AssetGroupMember
}

type AssetID [32]byte

type AssetLeaf struct {
	// Asset is the low-level asset record associated with this leaf, if
	// present.
	Asset *AssetRecord

	// Proof is the raw issuance or transfer proof bytes.
	Proof []byte
}

type AssetLeafKey struct {
	// Outpoint identifies the on-chain anchor point.
	Outpoint Outpoint

	// ScriptKey is the asset script key.
	ScriptKey PubKey
}

type AssetLeafKeysRequest struct {
	// ID identifies which universe to query.
	ID UniverseID

	// Offset is the page offset.
	Offset int32

	// Limit is the maximum number of keys to return.
	Limit int32

	// Direction is the page sort direction.
	Direction SortDirection
}

type AssetMeta struct {
	// Data is the raw metadata bytes. Limited to 1 MiB.
	Data []byte

	// Type is the metadata type.
	Type AssetMetaType

	// MetaHash is the hash of the TLV serialization of the meta.
	MetaHash Hash

	// UnknownOddTypes is a map of unknown odd TLV types encountered
	// during decoding.
	UnknownOddTypes map[uint64][]byte

	// DecimalDisplay is the number of decimal places for display.
	DecimalDisplay uint32

	// UniverseCommitments indicates whether the issuer publishes
	// universe supply commitments.
	UniverseCommitments bool

	// CanonicalUniverseURLs are the issuer's canonical universe URLs.
	CanonicalUniverseURLs []string

	// DelegationKey is the public key used to verify universe supply
	// commitment outputs and proofs.
	DelegationKey []byte
}

type AssetMetaType uint8

type AssetPacket struct {
	// AnchorTransaction is the raw bytes of the final Bitcoin anchor transaction.
	AnchorTransaction []byte

	// VirtualTransactions are the signed virtual asset transactions.
	VirtualTransactions [][]byte

	// PassiveAssetTransactions are the signed passive asset transactions.
	PassiveAssetTransactions [][]byte
}

type AssetProofPath struct {
	// ConfirmedBaseProof is the complete proof file ending at the last
	// confirmed asset state of the selected lineage.
	ConfirmedBaseProof []byte

	// Steps are ordered from the first unconfirmed child transition to the
	// selected leaf in the transaction tree.
	Steps []AssetProofPathStep
}

type AssetProofPathStep struct {
	TransitionProof []byte

	// CoInputPaths are complete proof paths for the co-inputs merged by
	// this step. The transition must spend exactly the spine tip plus every
	// co-path tip, and every co-path must carry the same asset identity as
	// the selected lineage.
	CoInputPaths []*AssetProofPath
}

type AssetProofPathStepSummary struct {
	// ContentID commits to the serialized transition proof.
	ContentID Hash

	// PreviousAnchorOutpoint is the anchor output consumed by the step.
	PreviousAnchorOutpoint Outpoint

	// AnchorOutpoint is the output containing the resulting asset state.
	AnchorOutpoint Outpoint

	// AnchorValueSat is the BTC value of the resulting anchor output.
	AnchorValueSat int64

	// AssetRef is the SDK-level identity of the resulting asset.
	AssetRef AssetRef

	// IssuanceID is the concrete asset issuance or tranche ID.
	IssuanceID AssetID

	// AssetType identifies a fungible or collectible asset.
	AssetType AssetType

	// Amount is the resulting asset amount.
	Amount uint64

	// ScriptKey locks the resulting asset state.
	ScriptKey PubKey

	// SplitAsset is true when this proof selects a non-root split output.
	SplitAsset bool
}

type AssetProofPathSummary struct {
	// ContentID commits to the complete canonical path.
	ContentID Hash

	// ConfirmedBaseProofID identifies the confirmed proof-file bytes.
	ConfirmedBaseProofID Hash

	// Depth is the number of unconfirmed transitions in the path.
	Depth uint16

	// AssetRef is the SDK-level identity of the selected asset.
	AssetRef AssetRef

	// IssuanceID is the concrete asset issuance or tranche ID.
	IssuanceID AssetID

	// AssetType identifies a fungible or collectible asset.
	AssetType AssetType

	// Amount is the asset amount at the selected path tip.
	Amount uint64

	// ScriptKey locks the selected asset state.
	ScriptKey PubKey

	// AnchorOutpoint locates the selected state in its anchor transaction.
	AnchorOutpoint Outpoint

	// AnchorValueSat is the BTC value of the selected anchor output.
	AnchorValueSat int64
}

type AssetProofResponse struct {
	// Key is the original request key.
	Key UniverseKey

	// UniverseRoot is the root that includes this proof.
	UniverseRoot *UniverseRoot

	// UniverseInclusionProof is the raw MS-SMT inclusion proof.
	UniverseInclusionProof []byte

	// AssetLeaf is the leaf containing the asset and proof.
	AssetLeaf *AssetLeaf

	// MultiverseRoot is the root of the wider multiverse tree.
	MultiverseRoot *MerkleSumNode

	// MultiverseInclusionProof is the multiverse inclusion proof.
	MultiverseInclusionProof []byte
}

type AssetQuerySort int

type AssetRecord struct {
	// AssetRef is the SDK's user-facing identifier inferred for this concrete
	// row. Grouped records use the group AssetRef; ungrouped records use the
	// issuance asset-ID AssetRef.
	AssetRef AssetRef

	// Version is the asset version.
	Version uint8

	// Genesis is the protocol issuance genesis for this concrete record.
	Genesis IssuanceGenesis

	// Amount is the asset amount.
	Amount uint64

	// LockTime is the CLTV lock time.
	LockTime uint64

	// RelativeLockTime is the CSV lock time.
	RelativeLockTime uint64

	// ScriptVersion is the script version.
	ScriptVersion uint16

	// ScriptKey is the script key.
	ScriptKey ScriptKey

	// AltLeaves are the auxiliary leaves.
	AltLeaves []AltLeaf
}

type AssetRef string

type AssetRootRequest struct {
	// WithAmountsByID includes per-asset-ID amounts for grouped assets.
	WithAmountsByID bool

	// Offset is the page offset.
	Offset int32

	// Limit is the maximum number of roots to return.
	Limit int32

	// Direction is the page sort direction.
	Direction SortDirection
}

type AssetStatsAsset struct {
	// AssetRef is the SDK's user-facing identifier for the asset.
	AssetRef AssetRef

	// IssuanceID is the 32-byte protocol-level identifier for the specific
	// issuance/tranche represented by this stats record.
	IssuanceID AssetID

	// GenesisPoint is the genesis outpoint string.
	GenesisPoint string

	// TotalSupply is the total units minted.
	TotalSupply int64

	// AssetName is the human-readable name.
	AssetName string

	// AssetType is the type (normal or collectible).
	AssetType AssetType

	// GenesisHeight is the block height at creation.
	GenesisHeight int32

	// GenesisTimestamp is the block timestamp (Unix seconds).
	GenesisTimestamp int64

	// AnchorPoint is the current anchor point string.
	AnchorPoint string

	// DecimalDisplay is the number of decimal places.
	DecimalDisplay uint32
}

type AssetStatsQuery struct {
	// AssetNameFilter filters by asset name substring.
	AssetNameFilter string

	// AssetRefFilter filters by a specific asset.
	AssetRefFilter *AssetRef

	// AssetTypeFilter restricts results to a specific asset type.
	AssetTypeFilter AssetTypeFilter

	// SortBy controls the sort field.
	SortBy AssetQuerySort

	// Offset is the pagination offset.
	Offset int32

	// Limit is the pagination page size.
	Limit int32

	// Direction is the sort direction.
	Direction SortDirection
}

type AssetStatsSnapshot struct {
	// AssetRef is the SDK's user-facing identifier for the asset.
	AssetRef AssetRef

	// GroupKey is the group key, if the asset belongs to a group.
	GroupKey *PubKey

	// GroupSupply is the total group supply (zero for ungrouped assets).
	GroupSupply int64

	// GroupAnchor is the group anchor asset stats, if grouped.
	GroupAnchor *AssetStatsAsset

	// Asset is the single asset stats, if not grouped.
	Asset *AssetStatsAsset

	// TotalSyncs is the sync count.
	TotalSyncs int64

	// TotalProofs is the proof count.
	TotalProofs int64
}

type AssetTransfer struct {
	// TransferTimestamp is the timestamp of the transfer in UTC Unix time
	// seconds.
	TransferTimestamp int64

	// TransferTxid is the anchor transaction ID (32 bytes, not reversed).
	TransferTxid [32]byte

	// AnchorTxid is the display-order transaction ID (string form).
	AnchorTxid string

	// AnchorTxHeightHint is the height hint of the anchor transaction.
	AnchorTxHeightHint uint32

	// AnchorTxChainFees is the total fees paid by the anchor transaction in
	// satoshis.
	AnchorTxChainFees int64

	// Inputs describes the set of spent assets.
	Inputs []TransferInput

	// Outputs describes the set of newly created asset outputs.
	Outputs []TransferOutput

	// AnchorTxBlockHash is the block hash of the blockchain block that contains
	// the anchor transaction (if confirmed).
	AnchorTxBlockHash [32]byte

	// AnchorTxBlockHashStr is the byte-reversed hash as a hex string (if
	// confirmed).
	AnchorTxBlockHashStr string

	// AnchorTxBlockHeight is the block height of the blockchain block that
	// contains the anchor transaction (0 if unconfirmed).
	AnchorTxBlockHeight uint32

	// Label is an optional short label for the transfer.
	Label string

	// AnchorTx is the raw anchor transaction bytes.
	AnchorTx []byte
}

type AssetType uint8

type AssetTypeFilter int

type AssetVersion uint8

type BackupMode uint8

type Balance struct {
	// AssetRef is the SDK identifier for the asset.
	AssetRef AssetRef

	// Balance is the confirmed amount owned by the wallet.
	Balance uint64
}

type BatchSibling struct {
	// FullTree provides the full tapscript tree.
	FullTree *TapscriptFullTree

	// Branch provides only the root branch hashes.
	Branch *TapBranch
}

type BatchState uint8

type Burn struct {
	// AssetRef is the user-facing identifier requested by the caller.
	AssetRef AssetRef

	// Amount is the number of units burned.
	Amount uint64

	// Note is optional user-defined metadata for this burn.
	Note string

	// Transfer is the wallet transfer that committed the burn.
	Transfer *AssetTransfer

	// Proof is the transition proof for the burn output.
	Proof *DecodedProof
}

type BurnAssetRequest struct {
	// AssetRef identifies which asset to burn units from.
	AssetRef AssetRef

	// AmountToBurn is the number of asset units to burn. Must be
	// greater than zero.
	AmountToBurn uint64

	// ConfirmationText must be set to "assets will be destroyed" for
	// the burn to succeed. This is a safety check.
	ConfirmationText string

	// Note is optional user-defined metadata for this burn.
	Note string
}

type BurnAssetResponse struct {
	// BurnTransfer is the asset transfer containing the burn output.
	BurnTransfer *AssetTransfer

	// BurnProof is the transition proof for the burn output.
	BurnProof *DecodedProof
}

type BurnOption func(*BurnOptions)

type BurnOptions struct {
	// contains filtered or unexported fields
}

type BurnRecord struct {
	// Note is user-defined metadata for the burn.
	Note string

	// AssetRef is the SDK's user-facing identifier for the burnt asset.
	AssetRef AssetRef

	// CollectionRef identifies the parent collection when the burnt asset
	// is an NFT collection item. It is nil for standalone NFTs and
	// fungible assets.
	CollectionRef *AssetRef

	// Type is the asset type reported by tapd for this burn. Use this
	// field for asset typing; AssetRef is the stable handle used to key
	// the burn record.
	Type AssetType

	// IssuanceID is the specific issuance/tranche that was burnt.
	IssuanceID AssetID

	// Amount is the number of burnt units.
	Amount uint64

	// AnchorTxid is the txid of the anchor transaction.
	AnchorTxid Hash
}

type CancelBatchResponse struct {
	// BatchKey is the internal public key of the cancelled batch.
	BatchKey PubKey
}

type Client interface {
	WalletClient
	ProofClient
	WalletKitClient
	UniverseClient
	MintClient
	EventClient

	Close() error
}

type Collection struct {
	// AssetRef is the stable SDK identifier for this collection.
	AssetRef AssetRef

	// ItemCount is the number of wallet-known NFT items in this collection.
	ItemCount uint64
}

type CollectionMintResult struct {
	// Collection is the collection-level entity keyed by group AssetRef.
	Collection *Collection

	// FirstItem is the NFT item minted to create the collection.
	FirstItem *Asset
}

type CommitVirtualPsbtsRequest struct {
	// AnchorPsbt is the caller-supplied BTC-level anchor PSBT template.
	AnchorPsbt []byte

	// VirtualPsbts are the active virtual asset PSBTs to commit.
	VirtualPsbts [][]byte

	// PassiveAssetPsbts are passive virtual asset PSBTs to commit alongside the
	// active PSBTs.
	PassiveAssetPsbts [][]byte

	// Funding controls backend anchor funding.
	Funding AnchorFundingPlan
}

type CommitVirtualPsbtsResponse struct {
	// AnchorPsbt is the funded BTC-level anchor PSBT with asset commitments.
	AnchorPsbt []byte

	// VirtualPsbts are the updated active virtual asset PSBTs.
	VirtualPsbts [][]byte

	// PassiveAssetPsbts are the updated passive virtual asset PSBTs.
	PassiveAssetPsbts [][]byte

	// ChangeOutputIndex is the index of the anchor change output or -1 if no
	// change output was added.
	ChangeOutputIndex int32

	// LockedUTXOs are the lnd wallet outpoints locked while funding the anchor
	// transaction.
	LockedUTXOs []Outpoint
}

type CommittedTransfer struct {
	// AnchorPsbt is the PSBT of the anchor transaction.
	AnchorPsbt []byte

	// VirtualPsbts are the committed virtual transaction PSBTs.
	VirtualPsbts [][]byte

	// PassiveAssetPsbts are the updated passive asset PSBTs.
	PassiveAssetPsbts [][]byte
}

type ConfirmedProofVerification struct {
	// AnchorAssetInventoryComplete asserts that the verifier examined the
	// full confirmed anchor commitment, not only one inclusion proof.
	AnchorAssetInventoryComplete bool

	// PassiveAssetCount is the number of other assets in the confirmed
	// anchor commitment. Compact paths currently require this to be zero.
	PassiveAssetCount uint32
}

type ConfirmedProofVerifier interface {
	VerifyConfirmedProof(ctx context.Context,
		proofFile []byte) (*ConfirmedProofVerification, error)
}

type CustomAnchorAssetInputSummary struct {
	// LogicalInputID is the stable caller-defined input identifier.
	LogicalInputID string `json:"logical_input_id"`

	// LogicalInputIndex is the caller-facing input position before one
	// logical selection is expanded into concrete issuance packets.
	LogicalInputIndex uint32 `json:"logical_input_index"`

	// PacketIndex identifies the committed virtual packet.
	PacketIndex uint32 `json:"packet_index"`

	// PacketRole selects the active or passive packet collection.
	PacketRole CustomAnchorPacketRole `json:"packet_role"`

	// VirtualInputIndex identifies the input within PacketIndex.
	VirtualInputIndex uint32 `json:"virtual_input_index"`

	// AnchorInputIndex identifies the input in the anchor transaction.
	AnchorInputIndex uint32 `json:"anchor_input_index"`

	// AssetRef is the caller-facing asset identity requested for the input.
	AssetRef AssetRef `json:"asset_ref"`

	// IssuanceID is the concrete asset issuance/tranche spent by this
	// input.
	IssuanceID AssetID `json:"issuance_id"`

	// AssetType is the concrete asset type for the input.
	AssetType AssetType `json:"asset_type"`

	// AnchorOutpoint is the BTC output that held the spent asset
	// commitment.
	AnchorOutpoint Outpoint `json:"anchor_outpoint"`

	// ScriptKey is the spent asset script key.
	ScriptKey PubKey `json:"script_key"`

	// Amount is the number of asset units spent.
	Amount uint64 `json:"amount"`

	// ProofSource identifies and persists the confirmed file or compact path
	// that selected this exact input.
	ProofSource CustomAnchorProofSourceSummary `json:"proof_source"`
}

type CustomAnchorAssetOutputSummary struct {
	// LogicalOutputID is the stable caller-defined output identifier.
	LogicalOutputID string `json:"logical_output_id"`

	// LogicalOutputIndex is the caller-facing output position before one
	// logical allocation is expanded into concrete issuance packets.
	LogicalOutputIndex uint32 `json:"logical_output_index"`

	// PacketIndex identifies the committed virtual packet.
	PacketIndex uint32 `json:"packet_index"`

	// PacketRole selects the active or passive packet collection.
	PacketRole CustomAnchorPacketRole `json:"packet_role"`

	// VirtualOutputIndex identifies the output within PacketIndex.
	VirtualOutputIndex uint32 `json:"virtual_output_index"`

	// AnchorOutputIndex is the output index in the anchor transaction.
	AnchorOutputIndex uint32 `json:"anchor_output_index"`

	// AssetRef is the caller-facing asset identity created at this output.
	AssetRef AssetRef `json:"asset_ref"`

	// IssuanceID is the concrete asset issuance/tranche created at this
	// output.
	IssuanceID AssetID `json:"issuance_id"`

	// AssetType is the concrete asset type for the output.
	AssetType AssetType `json:"asset_type"`

	// AnchorOutpoint is the BTC output that holds the new asset commitment.
	AnchorOutpoint Outpoint `json:"anchor_outpoint"`

	// AnchorValueSat is the BTC value assigned to the asset-bearing output.
	AnchorValueSat int64 `json:"anchor_value_sat"`

	// TaprootAssetRoot is the root of the Taproot Asset commitment before
	// combining it with the host-supplied tapscript sibling. Hosts such as
	// SwapDK use this root to compose their policy tree and control blocks.
	TaprootAssetRoot Hash `json:"taproot_asset_root"`

	// TaprootMerkleRoot is the final BIP341 root that combines the Taproot
	// Asset commitment with the optional host-supplied tapscript sibling.
	// It is the tweak committed to by the anchor output key.
	TaprootMerkleRoot Hash `json:"taproot_merkle_root"`

	// ScriptKey is the asset script key for the new output.
	ScriptKey PubKey `json:"script_key"`

	// Amount is the number of asset units created at this output.
	Amount uint64 `json:"amount"`

	// ScriptMode records how the active output script was constructed. Passive
	// reanchors use CustomAssetScriptUnspecified because their key is retained.
	ScriptMode CustomAssetScriptMode `json:"script_mode"`

	// ProofDelivery preserves the complete host-owned delivery metadata.
	ProofDelivery CustomAssetProofDelivery `json:"proof_delivery"`

	// OPTrueSpend contains the exact asset script-path witness data when the
	// output was built with CustomAssetScriptOPTrue. Other output modes leave
	// it nil.
	OPTrueSpend *CustomAssetOPTrueSpendInfo `json:"op_true_spend,omitempty"`
}

type CustomAnchorBackendMode string

type CustomAnchorCallerFundedExact struct{}

type CustomAnchorCallerSignedPlan struct{}

type CustomAnchorCapabilities struct {
	BackendMode CustomAnchorBackendMode

	CustomAnchorCommit       CustomAnchorCapabilityStatus
	CallerSuppliedAnchorPSBT CustomAnchorCapabilityStatus
	SkipFunding              CustomAnchorCapabilityStatus
	NoChangeOutput           CustomAnchorCapabilityStatus
	WalletFunding            CustomAnchorCapabilityStatus
	SkipBroadcast            CustomAnchorCapabilityStatus
	P2AAnchorOutput          CustomAnchorCapabilityStatus
	ExternalFeeBump          CustomAnchorCapabilityStatus
	ProofRegistration        CustomAnchorCapabilityStatus
	LocalVerification        CustomAnchorCapabilityStatus
	BackendVerification      CustomAnchorCapabilityStatus
}

type CustomAnchorCapability string

type CustomAnchorCapabilityProvider interface {
	CustomAnchorCapabilities(ctx context.Context) (
		*CustomAnchorCapabilities, error)
}

type CustomAnchorCapabilityStatus uint8

type CustomAnchorCommitAttemptError struct {
	Err            error
	FundingLock    CustomAnchorFundingLockMetadata
	OutcomeUnknown bool
}

type CustomAnchorCommitOptions struct {
	// Publish is the publish/log policy persisted for crash recovery.
	Publish CustomAnchorPublishMetadata
}

type CustomAnchorCommitResponseError struct {
	Err         error
	LockedUTXOs []CustomAnchorLockedUTXO
}

type CustomAnchorExternalP2AFeeBump struct {
	// P2AOutputIndex is the zero-based P2A output index in AnchorPSBT.
	P2AOutputIndex uint32
}

type CustomAnchorFundingLockMetadata struct {
	CustomLockID          []byte `json:"custom_lock_id"`
	LockExpirationSeconds uint64 `json:"lock_expiration_seconds"`
}

type CustomAnchorFundingMode uint8

type CustomAnchorFundingPlan struct {
	// Mode selects the active funding variant.
	Mode CustomAnchorFundingMode

	// WalletFunded configures backend wallet funding.
	WalletFunded *CustomAnchorWalletFunding

	// CallerFundedExact selects an exact caller-funded template.
	CallerFundedExact *CustomAnchorCallerFundedExact

	// ExternalP2AFeeBump selects an external P2A fee-bump plan.
	ExternalP2AFeeBump *CustomAnchorExternalP2AFeeBump
}

type CustomAnchorFundingSummary struct {
	// Mode is the high-level funding mode selected by the inspected plan.
	Mode CustomAnchorFundingMode `json:"mode"`

	// P2AOutputIndex is present only for external P2A fee-bump parents.
	P2AOutputIndex *uint32 `json:"p2a_output_index,omitempty"`

	// ActualFeeSat is the exact fee of the committed anchor transaction.
	ActualFeeSat uint64 `json:"actual_fee_sat"`

	// MaxFeeSat is the caller's hard ceiling for wallet-funded anchors. It is
	// zero for caller-funded exact and external zero-fee P2A parents.
	MaxFeeSat uint64 `json:"max_fee_sat"`
}

type CustomAnchorInputSigningPlan struct {
	// InputIndex is the input in the committed anchor transaction.
	InputIndex uint32 `json:"input_index"`

	// KeyPath selects a single-signer Taproot key spend.
	KeyPath *CustomAnchorKeyPathSigningPlan `json:"key_path,omitempty"`

	// MuSig2 selects a final aggregate MuSig2 Taproot key spend.
	MuSig2 *CustomAnchorMuSig2SigningPlan `json:"musig2,omitempty"`

	// ScriptPath selects one exact Taproot leaf spend.
	ScriptPath *CustomAnchorScriptPathSigningPlan `json:"script_path,omitempty"`

	// CallerSigned declares an input whose witness the caller supplies
	// out of band. The SDK derives no signing request and the backend
	// must not sign it.
	CallerSigned *CustomAnchorCallerSignedPlan `json:"caller_signed,omitempty"`
}

type CustomAnchorKeyPathSigningPlan struct {
	// Signer is the x-only internal key controlled by the signer.
	Signer XOnlyPubKey `json:"signer"`
}

type CustomAnchorKeyPathSigningRequest struct {
	ID                Hash
	PackageDigest     Hash
	InputIndex        uint32
	PrevOut           Outpoint
	PrevOutValueSat   int64
	PrevOutScript     []byte
	SighashType       uint32
	Sighash           Hash
	InternalKey       XOnlyPubKey
	TaprootMerkleRoot []byte
	Signer            XOnlyPubKey
}

type CustomAnchorLockedUTXO struct {
	// Outpoint identifies the locked BTC output.
	Outpoint Outpoint `json:"outpoint"`
}

type CustomAnchorLossAllowance struct {
	// AssetRef identifies the asset whose burn is being authorized.
	AssetRef AssetRef

	// MaxAmount is the maximum number of units that may be destroyed.
	MaxAmount uint64
}

type CustomAnchorLossMode uint8

type CustomAnchorLossPolicy struct {
	// Mode selects reject or explicitly bounded burn behavior.
	Mode CustomAnchorLossMode

	// Allowances contains the maximum explicit burn for each asset.
	Allowances []CustomAnchorLossAllowance

	// ConfirmIrreversibleLoss must be true before any burn is allowed.
	ConfirmIrreversibleLoss bool
}

type CustomAnchorMuSig2SigningPlan struct {
	// Participants are the ordered 33-byte compressed keys used for key
	// aggregation. Full keys preserve Y parity, so any cosigner key can
	// participate; callers whose aggregation sorts keys declare them
	// pre-sorted.
	Participants []PubKey `json:"participants"`

	// SessionContext is caller-defined public context used to distinguish
	// signing sessions. It must never contain a secret nonce.
	SessionContext []byte `json:"session_context"`
}

type CustomAnchorMuSig2SigningRequest struct {
	ID                Hash
	PackageDigest     Hash
	InputIndex        uint32
	PrevOut           Outpoint
	PrevOutValueSat   int64
	PrevOutScript     []byte
	SighashType       uint32
	Sighash           Hash
	InternalKey       XOnlyPubKey
	TaprootMerkleRoot []byte
	Participants      []PubKey
	SessionContext    []byte
}

type CustomAnchorOutputCommitmentPreview struct {
	// LogicalOutputID is the stable caller-defined output allocation ID.
	LogicalOutputID string

	// LogicalOutputIndex is the output position in the build request.
	LogicalOutputIndex uint32

	// PacketIndex identifies the prepared virtual packet.
	PacketIndex uint32

	// PacketRole identifies the active or passive packet collection.
	PacketRole CustomAnchorPacketRole

	// VirtualOutputIndex identifies the output within PacketIndex.
	VirtualOutputIndex uint32

	// AnchorOutputIndex identifies the output in the anchor transaction.
	AnchorOutputIndex uint32

	// TaprootAssetRoot is the root of the Taproot Asset commitment before
	// combining it with the host-supplied tapscript sibling.
	TaprootAssetRoot Hash

	// TaprootMerkleRoot is the final BIP341 root that combines the Taproot
	// Asset commitment with the optional host-supplied tapscript sibling.
	TaprootMerkleRoot Hash
}

type CustomAnchorOutputPlan struct {
	// InternalKey is the Taproot internal key for the BTC anchor output.
	InternalKey InternalKey

	// Tapscript optionally supplies an inspectable or opaque sibling form.
	Tapscript CustomAnchorTapscriptPlan
}

type CustomAnchorPacketRole uint8

type CustomAnchorPassiveAssets struct {
	// Policy selects reject, backend preserve, or caller re-anchor behavior.
	Policy CustomAnchorPassivePolicy

	// Packets are required only for caller re-anchor behavior.
	Packets []CustomAnchorPassivePacket
}

type CustomAnchorPassivePacket struct {
	// ID is a stable caller-defined identifier for the passive packet.
	ID string

	// AssetRef is the semantic identity of the passive asset.
	AssetRef AssetRef

	// Amount is the exact passive asset amount represented by the packet.
	Amount uint64

	// VirtualPSBT is the serialized passive virtual asset PSBT.
	VirtualPSBT []byte

	// ProofFile is the complete confirmed proof that selects the passive input.
	ProofFile []byte

	// ProofDelivery contains host-owned delivery metadata for the reanchored
	// passive proof.
	ProofDelivery CustomAssetProofDelivery
}

type CustomAnchorPassivePolicy uint8

type CustomAnchorPlan struct {
	// contains filtered or unexported fields
}

type CustomAnchorPlannedOutputSummary struct {
	// LogicalOutputID is the stable caller-defined output identifier.
	LogicalOutputID string

	// LogicalOutputIndex is the output position in the build request.
	LogicalOutputIndex uint32

	// PacketIndex identifies the prepared active virtual packet.
	PacketIndex uint32

	// PacketRole identifies the active packet collection.
	PacketRole CustomAnchorPacketRole

	// VirtualOutputIndex identifies the output within PacketIndex.
	VirtualOutputIndex uint32

	// AnchorOutputIndex identifies the output in the anchor transaction.
	AnchorOutputIndex uint32

	// AssetRef is the caller-facing semantic asset identity.
	AssetRef AssetRef

	// IssuanceID is the concrete issuance created by this packet output.
	IssuanceID AssetID

	// AssetType is the concrete asset type for the output.
	AssetType AssetType

	// Amount is the number of asset units assigned to the output.
	Amount uint64

	// AnchorValueSat is the BTC value assigned to the anchor output.
	AnchorValueSat uint64

	// ScriptKey is the concrete asset script key for the output.
	ScriptKey PubKey

	// ScriptMode records how the concrete script key was constructed.
	ScriptMode CustomAssetScriptMode

	// ProofDelivery preserves the complete host-owned delivery metadata.
	ProofDelivery CustomAssetProofDelivery

	// OPTrueSpend contains the exact script-path witness data when the output
	// uses CustomAssetScriptOPTrue. Other script modes leave it nil.
	OPTrueSpend *CustomAssetOPTrueSpendInfo
}

type CustomAnchorProofSourceKind uint8

type CustomAnchorProofSourceSummary struct {
	Kind      CustomAnchorProofSourceKind `json:"kind"`
	ContentID Hash                        `json:"content_id"`
	Blob      []byte                      `json:"blob"`
}

type CustomAnchorProofUpdate struct {
	// LogicalOutputID identifies the caller-facing output allocation.
	LogicalOutputID string `json:"logical_output_id"`

	// LogicalOutputIndex identifies the caller-facing output allocation.
	LogicalOutputIndex uint32 `json:"logical_output_index"`

	// PacketIndex identifies the committed virtual packet.
	PacketIndex uint32 `json:"packet_index"`

	// PacketRole selects the active or passive packet collection.
	PacketRole CustomAnchorPacketRole `json:"packet_role"`

	// VirtualOutputIndex identifies the output within PacketIndex.
	VirtualOutputIndex uint32 `json:"virtual_output_index"`

	// AnchorOutputIndex identifies the output in the anchor transaction.
	AnchorOutputIndex uint32 `json:"anchor_output_index"`

	// AssetRef is the caller-facing asset identity for the proof update.
	AssetRef AssetRef `json:"asset_ref"`

	// IssuanceID is the concrete asset issuance/tranche in the proof
	// update.
	IssuanceID AssetID `json:"issuance_id"`

	// ScriptKey identifies the receiver asset script key.
	ScriptKey PubKey `json:"script_key"`

	// AnchorOutpoint identifies the anchor output referenced by the proof.
	AnchorOutpoint Outpoint `json:"anchor_outpoint"`

	// ProofBlob is the proof suffix or proof metadata returned by the
	// backend.
	ProofBlob []byte `json:"proof_blob"`

	// ProofDelivery preserves the receiver and host delivery metadata.
	ProofDelivery CustomAssetProofDelivery `json:"proof_delivery"`
}

type CustomAnchorPublishAttemptError struct {
	Err            error
	OutcomeUnknown bool
}

type CustomAnchorPublishMetadata struct {
	// SkipAnchorTxBroadcast asks the backend to log without broadcasting
	// the final anchor transaction.
	SkipAnchorTxBroadcast bool `json:"skip_anchor_tx_broadcast"`

	// Label is an optional backend transfer label.
	Label string `json:"label"`

	// ExternalBroadcast records that the caller intends to broadcast, or
	// has already broadcast, the final anchor transaction outside the
	// backend.
	ExternalBroadcast bool `json:"external_broadcast"`
}

type CustomAnchorRequest struct {
	// Inputs are the proof-selected asset inputs to spend.
	Inputs []CustomAssetInput

	// Outputs are the logical asset outputs to create.
	Outputs []CustomAssetOutput

	// AnchorPSBT is the caller-visible BTC anchor transaction template.
	AnchorPSBT []byte

	// Funding selects exactly one high-level anchor funding mode.
	Funding CustomAnchorFundingPlan

	// PassiveAssets controls how co-anchored passive assets are handled.
	PassiveAssets CustomAnchorPassiveAssets

	// LossPolicy bounds explicitly requested protocol burn outputs. Asset
	// amounts must otherwise be conserved exactly.
	LossPolicy CustomAnchorLossPolicy

	// SigningPlans select the trusted external spend path for each BTC anchor
	// input. PSBT-bound validation occurs after the anchor template is decoded.
	SigningPlans []CustomAnchorInputSigningPlan
}

type CustomAnchorScriptPathSigningPlan struct {
	// LeafHash is the TapLeaf hash of the selected script path.
	LeafHash Hash `json:"leaf_hash"`

	// RequiredSigners are the x-only keys expected to contribute witness
	// signatures. An OP_TRUE-style leaf can leave this empty.
	RequiredSigners []XOnlyPubKey `json:"required_signers,omitempty"`
}

type CustomAnchorScriptPathSigningRequest struct {
	ID                Hash
	PackageDigest     Hash
	InputIndex        uint32
	PrevOut           Outpoint
	PrevOutValueSat   int64
	PrevOutScript     []byte
	SighashType       uint32
	Sighash           Hash
	InternalKey       XOnlyPubKey
	TaprootMerkleRoot []byte
	LeafHash          Hash
	LeafVersion       uint8
	LeafScript        []byte
	ControlBlock      []byte
	RequiredSigners   []XOnlyPubKey
}

type CustomAnchorSigningMode uint8

type CustomAnchorSigningRequests struct {
	KeyPath    []CustomAnchorKeyPathSigningRequest
	MuSig2     []CustomAnchorMuSig2SigningRequest
	ScriptPath []CustomAnchorScriptPathSigningRequest
}

type CustomAnchorTapscriptPlan struct {
	// TapLeaves is an ordered set of SDK tapscript leaves.
	TapLeaves []TapLeaf

	// SerializedSibling is an opaque serialized tapscript sibling.
	SerializedSibling []byte
}

type CustomAnchorTransferPackage struct {
	// SchemaVersion identifies the persisted package schema.
	SchemaVersion uint16 `json:"schema_version"`

	// PlanID binds the committed package to the immutable inspected plan.
	PlanID Hash `json:"plan_id"`

	// CommittedPackageDigest binds all committed package fields while
	// excluding signature and finalization fields in the anchor PSBT. It is
	// stable as external signatures are applied and is used by signing
	// request IDs.
	CommittedPackageDigest Hash `json:"committed_package_digest"`

	// UnsignedTxDigest binds the complete ordered unsigned anchor
	// transaction, including version, locktime, inputs, sequences, output
	// scripts, and output values.
	UnsignedTxDigest Hash `json:"unsigned_tx_digest"`

	// PackageDigest detects changes to the current persisted snapshot,
	// including signature and finalization fields.
	PackageDigest Hash `json:"package_digest"`

	// CommittedAnchorPsbt is the immutable post-commit BTC-level PSBT used
	// to derive signing requests and verify the current/final PSBT. It keeps
	// signing metadata that standard PSBT finalization removes.
	CommittedAnchorPsbt []byte `json:"committed_anchor_psbt"`

	// AnchorPsbt is the current BTC-level anchor PSBT. It initially equals
	// CommittedAnchorPsbt and is replaced on returned clones as signatures
	// or final witnesses are applied.
	AnchorPsbt []byte `json:"anchor_psbt"`

	// ActiveVirtualPsbts are the committed active virtual asset PSBTs.
	ActiveVirtualPsbts [][]byte `json:"active_virtual_psbts"`

	// PassiveVirtualPsbts are committed passive virtual asset PSBTs that
	// must remain paired with the active PSBTs when publishing or retrying.
	PassiveVirtualPsbts [][]byte `json:"passive_virtual_psbts"`

	// ChangeOutputIndex is the backend-selected change output index, or -1
	// when no change output exists.
	ChangeOutputIndex int32 `json:"change_output_index"`

	// LockedUTXOs are wallet UTXO locks held for backend-funded anchors.
	LockedUTXOs []CustomAnchorLockedUTXO `json:"locked_utxos"`

	// FundingLock preserves caller-supplied lease credentials and requested
	// expiration for recovery. Current tapd still returns no lease IDs.
	FundingLock CustomAnchorFundingLockMetadata `json:"funding_lock"`

	// Funding records the exact high-level funding policy and the actual
	// committed miner fee. It makes fee limits and the P2A output durable
	// across signing, restart, and external broadcast handoffs.
	Funding CustomAnchorFundingSummary `json:"funding"`

	// Inputs summarize the committed asset inputs without exposing
	// taproot-assets implementation types.
	Inputs []CustomAnchorAssetInputSummary `json:"inputs"`

	// Outputs summarize the committed asset outputs without exposing
	// taproot-assets implementation types.
	Outputs []CustomAnchorAssetOutputSummary `json:"outputs"`

	// ProofUpdates carry the proof metadata callers must keep for receiver
	// proof delivery, import, register, export, or retry flows.
	ProofUpdates []CustomAnchorProofUpdate `json:"proof_updates"`

	// SigningPlans select exactly one required external spending path for
	// each anchor input. The committed PSBT alone cannot safely infer that
	// intent when both key and script paths are available.
	SigningPlans []CustomAnchorInputSigningPlan `json:"signing_plans"`

	// BackendManagedInputIndices identifies anchor inputs that the backend
	// added or owns and will finalize through its anchor signer. Together
	// with SigningPlans, these indices must classify every anchor input
	// exactly once.
	BackendManagedInputIndices []uint32 `json:"backend_managed_input_indices"`

	// Publish stores publish/log retry metadata that is independent from
	// the final signed anchor PSBT bytes.
	Publish CustomAnchorPublishMetadata `json:"publish"`
}

type CustomAnchorTxBuilder struct {
	// contains filtered or unexported fields
}

type CustomAnchorVerificationCheck struct {
	// Code is the stable machine-readable check code.
	Code CustomAnchorVerificationCode

	// Scope identifies the subject being checked.
	Scope CustomAnchorVerificationScope

	// Origin identifies whether the SDK, backend, or integrating host
	// performed the check.
	Origin CustomAnchorVerificationOrigin

	// Passed reports whether the check succeeded.
	Passed bool

	// InputIndex optionally identifies an asset input.
	InputIndex *uint32

	// OutputIndex optionally identifies an anchor output.
	OutputIndex *uint32

	// OutputID optionally identifies a logical asset output.
	OutputID string

	// Message is diagnostic text and is not a stable API value.
	Message string
}

type CustomAnchorVerificationCode string

type CustomAnchorVerificationIssue struct {
	// Code is the stable machine-readable issue code.
	Code CustomAnchorVerificationCode

	// Scope identifies the affected part of the plan or package.
	Scope CustomAnchorVerificationScope

	// Origin identifies whether the SDK, backend, or integrating host reported
	// the issue.
	Origin CustomAnchorVerificationOrigin

	// Severity determines whether the issue invalidates the result.
	Severity CustomAnchorVerificationSeverity

	// InputIndex optionally identifies an asset input.
	InputIndex *uint32

	// OutputIndex optionally identifies an anchor output.
	OutputIndex *uint32

	// OutputID optionally identifies a logical asset output.
	OutputID string

	// Message is diagnostic text and is not a stable API value.
	Message string
}

type CustomAnchorVerificationOrigin uint8

type CustomAnchorVerificationResult struct {
	// Checks are the verification checkpoints that were attempted.
	Checks []CustomAnchorVerificationCheck

	// Issues are structured informational, warning, and error findings.
	Issues []CustomAnchorVerificationIssue
}

type CustomAnchorVerificationScope string

type CustomAnchorVerificationSeverity uint8

type CustomAnchorWalletFunding struct {
	// ChangeOutput selects backend change handling.
	ChangeOutput AnchorChangeOutput

	// Fee selects the backend fee policy.
	Fee AnchorFee

	// MaxFeeSat is the hard absolute fee ceiling for the committed anchor.
	// It is checked locally before any Bitcoin input is signed. This remains
	// required even when Fee uses a confirmation target because the backend
	// fee estimate is not itself a safe spending limit.
	MaxFeeSat uint64

	// CustomLockID is the required deterministic 32-byte identifier for
	// backend wallet UTXO locks and ambiguous-commit recovery.
	CustomLockID []byte

	// LockExpirationSeconds optionally overrides the backend lock duration.
	LockExpirationSeconds uint64
}

type CustomAnchorWalletKitClient interface {
	// CommitVirtualPsbtsWithRequest commits virtual transactions into the
	// caller-supplied anchor PSBT according to the exact funding plan.
	CommitVirtualPsbtsWithRequest(ctx context.Context,
		req *CommitVirtualPsbtsRequest) (*CommitVirtualPsbtsResponse,
		error)

	// PublishAndLogTransferWithRequest publishes or logs a finalized custom
	// anchor transfer together with the commit response metadata.
	PublishAndLogTransferWithRequest(ctx context.Context,
		req *PublishAndLogTransferRequest) (*AssetPacket, error)
}

type CustomAssetBurnScriptPlan struct{}

type CustomAssetExternalScriptPlan struct {
	// ScriptKey is the external Taproot Asset script key.
	ScriptKey ScriptKey
}

type CustomAssetInput struct {
	// ID is a stable caller-defined identifier for this logical input.
	ID string

	// AssetRef is the semantic asset identity expected at the selected proof
	// source tip.
	AssetRef AssetRef

	// Amount must exactly match the amount at the selected proof source tip.
	Amount uint64

	// ProofFile is a complete confirmed proof file. Exactly one of ProofFile
	// and ProofPath must be set.
	ProofFile []byte

	// ProofPath is a verified confirmed base plus zero or more compact
	// unconfirmed transitions. It requires a ConfirmedProofVerifier on the
	// builder, its UnconfirmedAnchorVerifier extension when steps are present,
	// and caller-provided asset witnesses.
	ProofPath *AssetProofPath

	// Witness selects how the virtual asset input is authorized.
	Witness CustomAssetWitnessPlan
}

type CustomAssetOPTrueScriptPlan struct {
	// InternalKey is unique to this logical output. Reusing it can produce a
	// duplicate asset commitment key and is rejected by the builder.
	InternalKey KeyDescriptor
}

type CustomAssetOPTrueSpendInfo struct {
	// LeafScript is the OP_TRUE tapscript program.
	LeafScript []byte `json:"leaf_script"`

	// LeafVersion is the tapscript leaf version committed by ControlBlock.
	LeafVersion uint8 `json:"leaf_version"`

	// ControlBlock proves LeafScript against the output asset script key.
	ControlBlock []byte `json:"control_block"`

	// InternalKey is the Taproot internal key committed by ControlBlock.
	InternalKey PubKey `json:"internal_key"`
}

type CustomAssetOutput struct {
	// ID is a stable caller-defined identifier used across planning, signing,
	// proof delivery, and persistence.
	ID string

	// AssetRef is the semantic identity of the asset being created.
	AssetRef AssetRef

	// Amount is the number of asset units assigned to this output.
	Amount uint64

	// AnchorOutputIndex is the output index in the caller anchor PSBT.
	AnchorOutputIndex uint32

	// AnchorValueSat is the exact BTC value required at the anchor output.
	AnchorValueSat uint64

	// Script selects exactly one asset script construction mode.
	Script CustomAssetScriptPlan

	// Anchor describes the anchor internal key and BTC tapscript sibling.
	Anchor CustomAnchorOutputPlan

	// ProofDelivery contains opaque receiver proof-delivery metadata.
	ProofDelivery CustomAssetProofDelivery

	// Timelocks contains asset-level lock times. Nonzero values are rejected
	// by the first custom-anchor implementation.
	Timelocks CustomAssetTimelocks
}

type CustomAssetProofDelivery struct {
	// RecipientID is an optional stable recipient or delivery identifier.
	RecipientID string `json:"recipient_id"`

	// CourierAddress is an optional proof courier destination.
	CourierAddress string `json:"courier_address"`

	// OpaqueMetadata is preserved for the host application's delivery flow.
	OpaqueMetadata []byte `json:"opaque_metadata"`
}

type CustomAssetScriptMode uint8

type CustomAssetScriptPlan struct {
	// Mode selects the active script variant.
	Mode CustomAssetScriptMode

	// Wallet selects a backend wallet-derived script key.
	Wallet *CustomAssetWalletScriptPlan

	// External selects a caller-supplied script key.
	External *CustomAssetExternalScriptPlan

	// OPTrue selects a unique OP_TRUE asset tapscript.
	OPTrue *CustomAssetOPTrueScriptPlan

	// Burn selects an explicitly unspendable asset output.
	Burn *CustomAssetBurnScriptPlan
}

type CustomAssetTimelocks struct {
	// Absolute is the asset-level absolute lock time.
	Absolute uint64

	// Relative is the asset-level relative lock time.
	Relative uint64
}

type CustomAssetWalletScriptPlan struct {
	// KeyLocator optionally requests a specific wallet key. Nil asks the
	// backend to derive a fresh key using its normal asset key family.
	KeyLocator *KeyLocator
}

type CustomAssetWitnessMode uint8

type CustomAssetWitnessPlan struct {
	// Mode selects backend signing or a caller-provided stack.
	Mode CustomAssetWitnessMode

	// Stack is the final witness stack for caller-provided mode.
	Stack [][]byte
}

type DeclareScriptKeyRequest struct {
	// ScriptKey is the script key to declare.
	ScriptKey ScriptKey
}

type DecodedProof struct {
	// ProofAtDepth is the index depth of this proof (0 = latest).
	ProofAtDepth uint32

	// NumberOfProofs is the total number of proofs in the chain.
	NumberOfProofs uint32

	// AssetRef is the SDK's user-facing identifier for the asset.
	AssetRef AssetRef

	// IssuanceID is the 32-byte protocol-level identifier for the specific
	// issuance/tranche described by the proof.
	IssuanceID AssetID

	// ScriptKey is the 33-byte script key.
	ScriptKey PubKey

	// Amount is the number of asset units.
	Amount uint64

	// Outpoint is the output location in "txid:index" format.
	Outpoint Outpoint

	// AltLeaves are auxiliary Taproot leaves committed alongside the asset.
	// Each entry is the raw per-leaf TLV stream bytes (opaque).
	AltLeaves [][]byte

	// PrevIDs are the asset-level identifiers of the inputs referenced by this
	// proof's asset witnesses. These are required to derive STXO alt leaves for
	// v1 transfer proofs.
	PrevIDs []PrevID

	// IsIssuance is true if this is a genesis/issuance proof.
	IsIssuance bool
}

type DerivedKeys struct {
	// ScriptKey is used to lock the asset to the receiver.
	ScriptKey ScriptKey

	// InternalKey is used as the internal key for the anchor output.
	InternalKey InternalKey
}

type Error struct {
	// Op is the operation that failed (e.g., "DeriveScriptKey").
	Op string

	// Err is the underlying error.
	Err error
}

type EventClient interface {
	// SubscribeReceiveEvents streams incoming asset transfer events.
	// Filter by address or start time via the request. The returned
	// channels are closed when the context is cancelled.
	SubscribeReceiveEvents(ctx context.Context,
		req *SubscribeReceiveEventsRequest) (
		<-chan *ReceiveEventRecord, <-chan error, error)

	// SubscribeSendEvents streams outgoing asset transfer events.
	// Filter by script key, label, or start time via the request.
	SubscribeSendEvents(ctx context.Context,
		req *SubscribeSendEventsRequest) (
		<-chan *SendEventRecord, <-chan error, error)

	// SubscribeMintEvents streams minting batch lifecycle events.
	SubscribeMintEvents(ctx context.Context,
		req *SubscribeMintEventsRequest) (
		<-chan *MintEvent, <-chan error, error)
}

type EventHandler struct {
	// OnReceive is called for each incoming asset transfer event.
	OnReceive func(ctx context.Context, event *ReceiveEvent)

	// OnSend is called for each outgoing asset transfer event.
	OnSend func(ctx context.Context, event *SendEvent)

	// OnMint is called for each minting batch lifecycle event.
	OnMint func(ctx context.Context, event *MintEvent)

	// OnError is called when a stream encounters a non-recoverable
	// error after all retry attempts are exhausted, or when a fatal
	// (non-retriable) error occurs. If nil, errors are silently
	// dropped and the stream is abandoned.
	OnError func(streamName string, err error)

	// OnDisconnect is called on every retriable stream break,
	// before the next reconnection attempt. err is the terminal
	// error returned by the stream (may be nil on a clean server
	// close) and nextRetry is the delay (with jitter) the listener
	// will wait before retrying. Intended for observability — to
	// surface transient hiccups as logs or metrics — while OnError
	// reports the terminal case.
	OnDisconnect func(streamName string, err error,
		nextRetry time.Duration)
}

type EventListener struct {
	// contains filtered or unexported fields
}

type EventListenerConfig struct {
	// MaxRetries is the maximum number of consecutive reconnection
	// attempts per stream before calling OnError. Zero means
	// unlimited retries.
	MaxRetries int

	// InitialBackoff is the delay before the first reconnection
	// attempt. Defaults to 1 second.
	InitialBackoff time.Duration

	// MaxBackoff caps the exponential backoff. Defaults to 60
	// seconds.
	MaxBackoff time.Duration

	// BackoffMultiplier is the factor applied after each retry.
	// Defaults to 2.0.
	BackoffMultiplier float64

	// ReceiveFilter optionally restricts receive events.
	ReceiveFilter *SubscribeReceiveEventsRequest

	// SendFilter optionally restricts send events.
	SendFilter *SubscribeSendEventsRequest

	// MintFilter optionally restricts mint events.
	MintFilter *SubscribeMintEventsRequest
}

type EventListenerOption func(*EventListenerConfig)

type ExportBackupRequest struct {
	Mode BackupMode
}

type ExportBackupResponse struct {
	Backup []byte
}

type ExternalIssuanceSigner interface {
	// SignIssuance reviews and signs one issuance authorization request.
	SignIssuance(context.Context, IssuanceSigningRequest) (
		SignedIssuance, error,
	)
}

type ExternalKey struct {
	// XPub is the account-level extended public key.
	XPub string

	// MasterFingerprint identifies the master key that derived XPub.
	MasterFingerprint [4]byte

	// DerivationPath is the full child derivation path.
	DerivationPath string
}

type FederationServer struct {
	// Host is the address of the federation server.
	Host string

	// ID is the numeric server identifier.
	ID int32
}

type FederationSyncConfig struct {
	// GlobalSyncConfigs are the per-proof-type configs.
	GlobalSyncConfigs []GlobalFederationSyncConfig

	// AssetSyncConfigs are the per-asset configs.
	AssetSyncConfigs []AssetFederationSyncConfig
}

type FeeRate struct {
	// contains filtered or unexported fields
}

type FetchAssetMetaRequest struct {
	// AssetRef identifies the asset whose metadata should be fetched.
	AssetRef *AssetRef

	// MetaHash is the 32-byte meta hash.
	MetaHash *Hash
}

type FinalizeBatchRequest struct {
	// ShortResponse asks the daemon to omit batch asset details.
	ShortResponse bool

	// FeeRate is the optional fee rate. Zero uses the daemon default.
	FeeRate FeeRate

	// BatchSibling is the optional tapscript sibling for the batch output.
	BatchSibling *BatchSibling
}

type FundBatchRequest struct {
	// ShortResponse asks the daemon to omit batch asset details.
	ShortResponse bool

	// FeeRate is the optional fee rate. Zero uses the daemon default.
	FeeRate FeeRate

	// BatchSibling is the optional tapscript sibling for the batch output.
	BatchSibling *BatchSibling
}

type FundedTransfer struct {
	// FundedPsbt is the funded virtual transaction PSBT.
	FundedPsbt []byte

	// PassiveAssetPsbts are the PSBTs for passive assets that need to be
	// re-signed.
	PassiveAssetPsbts [][]byte
}

type FungibleAssetSpec struct {
	// Name is the human-readable asset name.
	Name string

	// Amount is the number of units in the first issuance.
	Amount uint64

	// AssetMeta is the optional metadata committed to the first issuance.
	AssetMeta *AssetMeta

	// AssetVersion is the asset encoding version.
	AssetVersion AssetVersion

	// DecimalDisplay is the wallet display precision for the asset.
	DecimalDisplay uint32

	// ScriptKey is the optional custom script key for the first issuance.
	ScriptKey *ScriptKey

	// EnableSupplyCommitments enables supply commitments for the asset.
	EnableSupplyCommitments bool
}

type GenesisInfo struct {
	// GenesisPoint is the outpoint that created the asset.
	GenesisPoint string

	// Name is the asset name.
	Name string

	// MetaHash is the metadata hash committed into genesis.
	MetaHash Hash

	// IssuanceID is the protocol-level identifier for this concrete
	// issuance/tranche.
	IssuanceID AssetID

	// AssetType is the genesis asset type.
	AssetType AssetType

	// OutputIndex is the anchor output index in the genesis transaction.
	OutputIndex uint32
}

type GlobalFederationSyncConfig struct {
	// ProofType is the universe proof type this config applies to.
	ProofType ProofType

	// AllowSyncInsert enables federation insert for this type.
	AllowSyncInsert bool

	// AllowSyncExport enables federation export for this type.
	AllowSyncExport bool
}

type GroupKeyRequest struct {
	// RawKey is the group internal key when locally managed.
	RawKey *KeyDescriptor

	// AnchorGenesis is the genesis of the asset anchoring the group.
	AnchorGenesis *GenesisInfo

	// TapscriptRoot is the optional tapscript root used in the group key.
	TapscriptRoot []byte

	// NewAsset is the serialized asset requesting group membership.
	NewAsset []byte

	// ExternalKey is the external key used for group signing, if any.
	ExternalKey *ExternalKey
}

type GroupVirtualTx struct {
	// Transaction is the serialized virtual transaction.
	Transaction []byte

	// PrevOut is the output being spent in the virtual transaction.
	PrevOut *TxOut

	// GenesisID is the grouped asset's asset ID.
	GenesisID AssetID

	// TweakedKey is the tweaked group key for the request.
	TweakedKey *PubKey
}

type GroupWitness struct {
	// GenesisID identifies the pending asset to authorize.
	GenesisID AssetID

	// Witness is the serialized witness stack.
	Witness [][]byte
}

type GroupedUniverseEvents struct {
	// Date is the day formatted as YYYY-MM-DD.
	Date string

	// SyncEvents is the number of sync events on this day.
	SyncEvents uint64

	// NewProofEvents is the number of new proof events on this day.
	NewProofEvents uint64
}

type Hash [32]byte

type ImportBackupRequest struct {
	Backup []byte
}

type ImportBackupResponse struct {
	NumImported uint32
}

type Info struct {
	// Version is the version that tapd is running.
	Version string

	// LndVersion is the full version string of the LND node tapd is connected to.
	LndVersion string

	// Network is the network tapd is connected to,
	// e.g. "mainnet", "testnet", or any other supported network.
	Network string

	// LndIdentityPubkey is the public key of the LND node tapd is connected to.
	LndIdentityPubkey PubKey

	// NodeAlias is the alias of the LND node tapd is connected to.
	NodeAlias string

	// BlockHeight is the best block height that tapd has knowledge of.
	BlockHeight uint32

	// BlockHash is the current block hash as seen by the LND node
	// tapd is connected to.
	BlockHash chainhash.Hash

	// SyncedToChain is true if the wallet's view is synced to the main
	// chain.
	SyncedToChain bool
}

type InteractiveSendRequest struct {
	// AssetRef identifies the asset to send.
	AssetRef AssetRef

	// Amount is the number of asset units to send.
	Amount uint64

	// ReceiverKeys contains the keys derived by the receiver.
	ReceiverKeys DerivedKeys
}

type InteractiveTxBuilder struct {
	// contains filtered or unexported fields
}

type InternalKey struct {
	// PubKey is the raw public key bytes (33 bytes compressed).
	PubKey PubKey

	// KeyLocator identifies the key's derivation path.
	KeyLocator KeyLocator
}

type Issuance struct {
	// AssetRef is the stable SDK identifier of the fungible asset this
	// issuance belongs to.
	AssetRef AssetRef

	// IssuanceID is the protocol-level asset ID for this tranche.
	IssuanceID AssetID

	// Name is the human-readable asset tag.
	Name string

	// MetaHash is the issuance metadata hash.
	MetaHash Hash

	// Amount is the sum of wallet rows returned by the ListIssuances request
	// for this tranche. With the default request this is wallet-known,
	// confirmed, unspent, and unleased amount, not total issued supply.
	Amount uint64
}

type IssuanceGenesis struct {
	// FirstPrevOut is the outpoint of the first input of the genesis transaction.
	FirstPrevOut Outpoint

	// Tag is the asset tag.
	Tag string

	// MetaHash is the meta data hash.
	MetaHash Hash

	// IssuanceID is the unique 32-byte protocol-level identifier for this
	// specific issuance/tranche.
	IssuanceID AssetID

	// OutputIndex is the output index of the genesis transaction.
	OutputIndex uint32

	// Type is the asset type.
	Type AssetType
}

type IssuanceOperation uint8

type IssuanceSigningRequest struct {
	// Operation is the high-level issuer action being authorized.
	Operation IssuanceOperation

	// AssetRef is the stable SDK identifier for the Asset or Collection. For a
	// first issuance this is inferred from the funded signing payload.
	AssetRef AssetRef

	// Name is the Asset or Collection item name.
	Name string

	// AssetType is the kind of asset being issued.
	AssetType AssetType

	// Amount is the number of units this signing request authorizes.
	Amount uint64

	// ScriptKey is the asset-level spending key for the issued units.
	ScriptKey *ScriptKey

	// ExternalKey is the external key descriptor that should sign.
	ExternalKey ExternalKey

	// AnchorGenesis is the concrete genesis information committed by the funded
	// mint batch.
	AnchorGenesis *GenesisInfo

	// VirtualPSBT is the base64 PSBT that must be signed externally.
	VirtualPSBT string

	// VirtualTx is the decoded virtual transaction metadata for review.
	VirtualTx *GroupVirtualTx
}

type Issuer struct {
	// contains filtered or unexported fields
}

type KeyDescriptor struct {
	// RawKeyBytes is the raw public key bytes (33 bytes compressed).
	RawKeyBytes PubKey

	// KeyLocator identifies the key's derivation path.
	KeyLocator KeyLocator
}

type KeyLocator struct {
	// Family is the key family (derivation purpose).
	Family uint32

	// Index is the specific key index within the family.
	Index uint32
}

type ListAssetsRequest struct {
	// WithWitness includes asset witnesses in low-level records. It is
	// forwarded to tapd unchanged by all listing surfaces.
	WithWitness bool

	// IncludeSpent includes spent assets. It is forwarded to tapd unchanged
	// by all listing surfaces.
	IncludeSpent bool

	// IncludeLeased includes leased assets. It is forwarded to tapd
	// unchanged by all listing surfaces.
	IncludeLeased bool

	// IncludeUnconfirmedMints includes freshly minted assets before anchor
	// confirmation. It is forwarded to tapd unchanged by all listing
	// surfaces.
	IncludeUnconfirmedMints bool

	// MinAmount filters by amount. Wallet.ListAssets applies it after
	// aggregating protocol rows into semantic assets; low-level
	// Client.ListAssetRecords forwards it to tapd as a per-record filter.
	// Zero means unset.
	MinAmount uint64

	// MaxAmount filters by amount. Wallet.ListAssets applies it after
	// aggregating protocol rows into semantic assets; low-level
	// Client.ListAssetRecords forwards it to tapd as a per-record filter.
	// Zero means unset.
	MaxAmount uint64

	// AssetRef filters by SDK asset identity. Group refs are forwarded to
	// tapd's group_key filter; asset-ID refs are matched locally because
	// tapd's asset listing endpoint has no asset-ID filter.
	AssetRef *AssetRef

	// AnchorOutpoint filters records by the Bitcoin outpoint that anchors
	// them. It is forwarded to tapd unchanged.
	AnchorOutpoint *Outpoint

	// ScriptKeyType filters by script-key role. It is forwarded to tapd
	// unchanged after SDK-side validation.
	ScriptKeyType *ScriptKeyTypeQuery
}

type ListBalancesRequest struct {
	// AssetRef restricts the result to a single asset.
	AssetRef *AssetRef

	// IncludeLeased includes assets that are currently leased by a pending
	// transfer and therefore unavailable for coin selection.
	IncludeLeased bool

	// ScriptKeyType optionally restricts balances to a specific script key
	// type or all types.
	ScriptKeyType *ScriptKeyTypeQuery
}

type ListBalancesResponse struct {
	// Balances is keyed by AssetRef.String().
	Balances map[string]*Balance

	// UnconfirmedTransfers counts outgoing transfers that are not yet
	// confirmed on-chain and therefore excluded from the reported balances.
	UnconfirmedTransfers uint64
}

type ListBatchesRequest struct {
	// BatchKey filters the response to a single batch when set.
	BatchKey *PubKey

	// Verbose asks the daemon to include unsealed asset details.
	Verbose bool
}

type ListBurnsRequest struct {
	// AssetRef filters by the burnt asset.
	AssetRef *AssetRef

	// AnchorTxid filters by the anchor transaction id.
	AnchorTxid *Hash
}

type ListCollectionItemsRequest struct {
	// CollectionRef filters by collection AssetRef.
	CollectionRef *AssetRef

	// AssetRef filters by a single NFT AssetRef.
	AssetRef *AssetRef
}

type ListCollectionsRequest struct {
	// AssetRef filters by collection AssetRef.
	AssetRef *AssetRef
}

type ListIssuancesRequest struct {
	// AssetRef filters by the fungible asset. For grouped fungibles this is
	// the group-key AssetRef.
	AssetRef *AssetRef
}

type ListTransfersRequest struct {
	// AnchorTxid specifies the hexadecimal encoded txid string of the anchor
	// transaction for which to retrieve transfers. An empty value indicates
	// that this parameter should be disregarded in transfer selection.
	AnchorTxid string
}

type ListUtxosRequest struct {
	// IncludeLeased includes UTXOs that are marked as leased.
	IncludeLeased bool

	// ScriptKeyType filters the assets by script key type.
	ScriptKeyType *ScriptKeyTypeQuery
}

type MacaroonSource = macaroon.Source

type ManagedUtxo struct {
	// OutPoint is the outpoint of the UTXO.
	OutPoint Outpoint

	// AmtSat is the UTXO amount in satoshis.
	AmtSat int64

	// InternalKey is the internal key used for the on-chain output.
	InternalKey PubKey

	// TaprootAssetRoot is the Taproot Asset root commitment hash.
	TaprootAssetRoot Hash

	// MerkleRoot is the Taproot merkle root hash.
	MerkleRoot Hash

	// Assets are the low-level asset records held at this UTXO.
	Assets []*AssetRecord

	// LeaseOwner is the lease owner for this UTXO. Empty if unleased.
	LeaseOwner []byte

	// LeaseExpiryUnix is the unix timestamp when the lease expires.
	// Zero if unleased.
	LeaseExpiryUnix int64
}

type MerkleSumNode struct {
	// RootHash is the MS-SMT root hash.
	RootHash Hash

	// RootSum is the aggregate supply sum of the subtree.
	RootSum int64
}

type MintAsset struct {
	// AssetVersion is the asset encoding version.
	AssetVersion AssetVersion

	// AssetType is the type of asset to mint.
	AssetType AssetType

	// Name is the asset tag.
	Name string

	// AssetMeta is the optional metadata committed to the genesis.
	AssetMeta *AssetMeta

	// InitialSupply is the number of units in the first issuance.
	InitialSupply uint64

	// AllowIssuance creates the asset with a group key so future issuances are
	// possible.
	AllowIssuance bool

	// DecimalDisplay is the wallet display precision for the asset.
	DecimalDisplay uint32

	// ScriptKey is the optional custom script key for the first issuance.
	ScriptKey *ScriptKey

	// GroupInternalKey is the internal key for a newly issuable asset.
	GroupInternalKey *KeyDescriptor

	// GroupTapscriptRoot is the optional tapscript root for a newly issuable
	// asset.
	GroupTapscriptRoot []byte

	// ExternalGroupKey enables external signing for future issuance.
	ExternalGroupKey *ExternalKey

	// EnableSupplyCommitments enables supply commitments for a newly issuable
	// asset.
	EnableSupplyCommitments bool
}

type MintAssetRequest struct {
	// Asset is the asset to mint.
	Asset *MintAsset

	// ShortResponse asks the daemon to omit existing batch assets.
	ShortResponse bool
}

type MintClient interface {
	// MintAsset adds a brand-new asset to the pending mint batch.
	MintAsset(ctx context.Context,
		req *MintAssetRequest) (*MintingBatch, error)

	// MintIssuance adds an additional issuance/tranche for an existing
	// asset in the pending mint batch.
	MintIssuance(ctx context.Context,
		req *MintIssuanceRequest) (*MintingBatch, error)

	// FundBatch funds the current pending mint batch.
	FundBatch(ctx context.Context,
		req *FundBatchRequest) (*VerboseMintingBatch,
		error)

	// SealBatch seals a funded batch before finalization.
	SealBatch(ctx context.Context,
		req *SealBatchRequest) (*MintingBatch, error)

	// FinalizeBatch finalizes the current pending mint batch.
	FinalizeBatch(ctx context.Context,
		req *FinalizeBatchRequest) (*MintingBatch, error)

	// CancelBatch cancels the current mint batch.
	CancelBatch(ctx context.Context) (*CancelBatchResponse, error)

	// ListBatches lists mint batches known to the daemon.
	ListBatches(ctx context.Context,
		req *ListBatchesRequest) ([]*VerboseMintingBatch,
		error)
}

type MintEvent struct {
	// Timestamp is the event execution time as a Unix timestamp in
	// microseconds.
	Timestamp int64

	// BatchState is the last batch state that was executed. If Error
	// is set, this is the state that caused the failure.
	BatchState BatchState

	// Batch contains the minting batch details.
	Batch *MintingBatch

	// Error is an optional error string.
	Error string
}

type MintIssuance struct {
	// AssetRef identifies the asset to issue more units of. It must resolve to a
	// group key.
	AssetRef AssetRef

	// Name is the asset tag of the existing asset. tapd still requires it on the
	// underlying mint request.
	Name string

	// AssetType is the type of the existing asset.
	AssetType AssetType

	// AssetMeta is the optional metadata committed to this issuance.
	AssetMeta *AssetMeta

	// Amount is the number of units to issue in this tranche.
	Amount uint64

	// AssetVersion is the asset encoding version.
	AssetVersion AssetVersion

	// DecimalDisplay is the display precision for the issuance metadata.
	DecimalDisplay uint32

	// ScriptKey is the optional custom script key for the issuance.
	ScriptKey *ScriptKey

	// ExternalGroupKey enables external signing for the group issuance.
	ExternalGroupKey *ExternalKey
}

type MintIssuanceRequest struct {
	// Issuance is the issuance to mint.
	Issuance *MintIssuance

	// ShortResponse asks the daemon to omit existing batch assets.
	ShortResponse bool
}

type MintOption func(*MintOptions)