supplycommit

type AssetLookup interface {
	// FetchSupplyCommitAssets fetches all assets with non-nil group keys
	// that are supply commitments enabled.
	FetchSupplyCommitAssets(ctx context.Context,
		localControlled bool) ([]btcec.PublicKey, error)

	// QueryAssetGroupByID attempts to fetch an asset group by its asset ID.
	// If the asset group cannot be found, then ErrAssetGroupUnknown is
	// returned.
	QueryAssetGroupByID(ctx context.Context,
		assetID asset.ID) (*asset.AssetGroup, error)

	// QueryAssetGroupByGroupKey fetches the asset group with a matching
	// tweaked key, including the genesis information used to create the
	// group.
	QueryAssetGroupByGroupKey(ctx context.Context,
		groupKey *btcec.PublicKey) (*asset.AssetGroup, error)

	// FetchAssetMetaForAsset attempts to fetch an asset meta based on an
	// asset ID.
	FetchAssetMetaForAsset(ctx context.Context,
		assetID asset.ID) (*proof.MetaReveal, error)

	// FetchInternalKeyLocator attempts to fetch the key locator information
	// for the given raw internal key. If the key cannot be found, then
	// ErrInternalKeyNotFound is returned.
	FetchInternalKeyLocator(ctx context.Context,
		rawKey *btcec.PublicKey) (keychain.KeyLocator, error)
}

type BroadcastEvent struct {
	// SignedCommitPkt is the signed commitment transaction that will be
	// broadcast to the network.
	SignedCommitPkt *psbt.Packet
}

type ChainProof struct {
	// Header is the block header of the block that contains the supply
	// commitment transaction.
	Header wire.BlockHeader

	// BlockHeight is the block height of the block that contains the supply
	// commitment transaction.
	BlockHeight uint32

	// MerkleProof is the merkle proof that proves that the supply
	// commitment transaction is included in the block.
	MerkleProof proof.TxMerkleProof

	// TxIndex is the index of the supply commitment transaction in the
	// block.
	TxIndex uint32
}

type CommitBroadcastState struct {
	// SupplyTransition holds all the information about the current state
	// transition, including old/new trees and commitments.
	SupplyTransition SupplyStateTransition
}

type CommitFinalizeState struct {
	// SupplyTransition holds all the information about the current state
	// transition, including old/new trees and commitments.
	SupplyTransition SupplyStateTransition
}

type CommitTickEvent struct {
}

type CommitTreeCreateState struct {
}

type CommitTxCreateState struct {
	// SupplyTransition holds all the information about the current state
	// transition, including old/new trees and commitments.
	SupplyTransition SupplyStateTransition
}

type CommitTxSignState struct {
	// SupplyTransition holds all the information about the current state
	// transition, including old/new trees and commitments.
	SupplyTransition SupplyStateTransition
}

type CommitmentBlock struct {
	// Height is the block height of the block that contains the
	// commitment.
	Height uint32

	// Hash is the hash of the block that contains the commitment.
	Hash chainhash.Hash

	// TxIndex is the index of the supply commitment transaction within
	// the block.
	TxIndex uint32

	// BlockHeader is the block header of the block that contains the
	// commitment.
	BlockHeader *wire.BlockHeader

	// MerkleProof is the merkle proof that proves that the supply
	// commitment transaction is included in the block.
	MerkleProof *proof.TxMerkleProof

	// ChainFees is the amount in sats paid in on-chain fees for the
	// supply commitment transaction.
	ChainFees int64
}

type CommitmentTracker interface {
	// UnspentPrecommits returns the set of unspent pre-commitments for a
	// given asset spec. The asset spec will only specify a group key, and
	// not also an asset ID.
	UnspentPrecommits(ctx context.Context, assetSpec asset.Specifier,
		localIssuerOnly bool) lfn.Result[PreCommits]

	// SupplyCommit returns the root commitment for a given asset spec. From
	// the PoV of the chain, this is a singleton instance.
	SupplyCommit(ctx context.Context,
		assetSpec asset.Specifier) RootCommitResp
}

type ConfEvent struct {
	// BlockHeight is the height of the block in which the transaction was
	// confirmed within.
	BlockHeight uint32

	// TxIndex is the index within the block of the ultimate confirmed
	// transaction.
	TxIndex uint32

	// Tx is the transaction for which the notification was requested for.
	Tx *wire.MsgTx

	// Block is the block that contains the transaction referenced above.
	Block *wire.MsgBlock
}

type ConfMapper = protofsm.ConfMapper[ConfEvent]

type Config = protofsm.StateMachineCfg[Event, *Environment]

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

type CreateTxEvent struct {
}

type DaemonAdapters interface {
	protofsm.DaemonAdapters

	// Start starts the daemon adapters handler service.
	Start() error

	// Stop stops the daemon adapters handler service.
	Stop() error
}

type DefaultState struct {
}

type Environment struct {
	// AssetSpec is the asset specifier that is used to identify the asset
	// that we're maintaining a supply commit for.
	AssetSpec asset.Specifier

	// TreeView is the interface that allows the state machine to obtain an
	// up to date snapshot of the root supply tree, and the relevant set of
	// subtrees.
	TreeView SupplyTreeView

	// Commitments is used to track the state of the pre-commitment and
	// commitment outputs that are currently confirmed on-chain.
	Commitments CommitmentTracker

	// Wallet is the main wallet interface used to managed PSBT packets.
	Wallet Wallet

	// AssetLookup is used to look up asset information such as asset groups
	// and asset metadata.
	AssetLookup AssetLookup

	// KeyRing is the main key ring interface used to manage keys.
	KeyRing KeyRing

	// Chain is our access to the current main chain.
	//
	// TODO(roasbeef): can make a slimmer version of
	Chain tapgarden.ChainBridge

	// SupplySyncer is used to insert supply commitments into the remote
	// universe server.
	SupplySyncer SupplySyncer

	// StateLog is the main state log that is used to track the state of the
	// state machine. This is used to persist the state of the state machine
	// across restarts.
	StateLog StateMachineStore

	// CommitConfTarget is the confirmation target used when crafting the
	// commitment transaction.
	CommitConfTarget uint32

	// ChainParams is the chain parameters for the chain that we're
	// operating on.
	ChainParams chaincfg.Params

	// IgnoreCheckerCache is used to invalidate the ignore cache when a new
	// supply commitment is created.
	IgnoreCheckerCache IgnoreCheckerCache

	// Log is the prefixed logger for this supply commitment state machine.
	Log btclog.Logger
}

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

type Event interface {
	// contains filtered or unexported methods
}

type Events interface {
}

type FetchCommitmentResp struct {
	// SupplyTree is the supply tree for an asset. The leaves of this tree
	// commit to the roots of the supply commit subtrees.
	SupplyTree mssmt.Tree

	// Subtrees maps a subtree type to its corresponding supply subtree.
	Subtrees SupplyTrees

	// ChainCommitment links the supply tree to its anchor transaction.
	ChainCommitment RootCommitment
}

type FetchSupplyCommitResult struct {
	// RootCommitment contains the commitment transaction and output data.
	RootCommitment RootCommitment

	// SupplyLeaves contains the issuance, burn, and ignore leaves.
	SupplyLeaves SupplyLeaves

	// ChainProof contains the block header and merkle proof.
	ChainProof ChainProof

	// TxChainFeesSats is the total number of satoshis in on-chain fees
	// paid by the supply commitment transaction.
	TxChainFeesSats int64

	// IssuanceSubtreeRoot is the root of the issuance tree for the asset.
	IssuanceSubtreeRoot SubtreeRootProof

	// BurnSubtreeRoot is the root of the burn tree for the asset.
	BurnSubtreeRoot SubtreeRootProof

	// IgnoreSubtreeRoot is the root of the ignore tree for the asset.
	IgnoreSubtreeRoot SubtreeRootProof

	// SpentCommitmentOutpoint is the outpoint of the previous commitment
	// that this new commitment is spending. This is None for the very
	// first supply commitment of a grouped asset.
	SpentCommitmentOutpoint fn.Option[wire.OutPoint]
}

type FinalizeEvent struct {
}

type FsmEvent = protofsm.EmittedEvent[Event]

type FsmState = protofsm.State[Event, *Environment]

type IgnoreCheckerCache interface {
	// InvalidateCache is used to invalidate the ignore checker cache when
	// a new supply commitment is created.
	InvalidateCache(btcec.PublicKey)
}

type KeyRing interface {
	// DeriveNextTaprootAssetKey attempts to derive the *next* key within
	// the Taproot Asset key family.
	DeriveNextTaprootAssetKey(ctx context.Context) (keychain.KeyDescriptor,
		error)
}

type Manager struct {

	// ContextGuard provides a wait group and main quit channel that can be
	// used to create guarded contexts.
	*fn.ContextGuard
	// contains filtered or unexported fields
}

type ManagerCfg struct {
	// TreeView is the interface that allows the state machine to obtain an
	// up-to-date snapshot of the root supply tree, and the relevant set of
	// subtrees.
	TreeView SupplyTreeView

	// Commitments is used to track the state of the pre-commitment and
	// commitment outputs that are currently confirmed on-chain.
	Commitments CommitmentTracker

	// Wallet is the interface used interact with the wallet.
	Wallet Wallet

	// AssetLookup is used to look up asset information such as asset groups
	// and asset metadata.
	AssetLookup AssetLookup

	// Signer is used to sign messages with a key specified by a key
	// locator.
	Signer lndclient.SignerClient

	// KeyRing is the key ring used to derive new keys.
	KeyRing KeyRing

	// Chain is our access to the current main chain.
	//
	// TODO(roasbeef): can make a slimmer version of
	Chain tapgarden.ChainBridge

	// SupplySyncer is used to insert supply commitments into the remote
	// universe server.
	SupplySyncer SupplySyncer

	// DaemonAdapters is a set of adapters that allow the state machine to
	// interact with external daemons whilst processing internal events.
	DaemonAdapters DaemonAdapters

	// StateLog is the main state log that is used to track the state of the
	// state machine. This is used to persist the state of the state machine
	// across restarts.
	StateLog StateMachineStore

	// ChainParams is the chain parameters for the chain that we're
	// operating on.
	ChainParams chaincfg.Params

	// IgnoreCheckerCache is used to invalidate the ignore cache when a new
	// supply commitment is created.
	IgnoreCheckerCache IgnoreCheckerCache
}

type MockAssetLookup struct {
	mock.Mock
}

type MockCommitmentTracker struct {
	mock.Mock
}

type NewBurnEvent struct {
	universe.BurnLeaf

	// Done is an optional channel that will receive an error (or nil for
	// success) when the event has been processed and written to disk.
	// If nil, the event is processed asynchronously.
	Done chan error
}

type NewIgnoreEvent struct {
	universe.SignedIgnoreTuple

	// Done is an optional channel that will receive an error (or nil for
	// success) when the event has been processed and written to disk. If
	// nil, the event is processed asynchronously.
	Done chan error
}

type NewMintEvent struct {
	// LeafKey is the universe leaf key for the asset issuance or spend.
	LeafKey universe.UniqueLeafKey

	// IssuanceProof is the universe leaf for the issuance.
	IssuanceProof universe.Leaf

	// MintHeight is the height of the block that contains the mint.
	MintHeight uint32

	// Done is an optional channel that will receive an error (or nil for
	// success) when the event has been processed and written to disk.
	// If nil, the event is processed asynchronously.
	Done chan error
}

type PreCommitment struct {
	// BlockHeight is the block height of the transaction that contains the
	// pre-commitment.
	BlockHeight uint32

	// MintingTxn is the minting transaction itself that created the pre
	// commitment.
	MintingTxn *wire.MsgTx

	// OutIdx specifies the index of the pre-commitment output within the
	// batch mint anchor transaction.
	OutIdx uint32

	// InternalKey is the Taproot internal public key associated with the
	// pre-commitment output.
	InternalKey keychain.KeyDescriptor

	// GroupPubKey is the asset group public key associated with this
	// pre-commitment output.
	GroupPubKey btcec.PublicKey
}

type PreCommits = []PreCommitment

type RootCommitResp = lfn.Result[lfn.Option[RootCommitment]]

type RootCommitment struct {
	// Txn is the transaction that created the root commitment.
	Txn *wire.MsgTx

	// TxOutIdx is the index of the output in the transaction where the
	// commitment resides.
	TxOutIdx uint32

	// InternalKey is the internal key used to create the commitment output.
	InternalKey keychain.KeyDescriptor

	// Output key is the taproot output key used to create the commitment
	// output.
	OutputKey *btcec.PublicKey

	// SupplyRoot is the root of the supply tree that contains the set of
	// sub-commitments. The sum value of this tree is the outstanding supply
	// value.
	SupplyRoot *mssmt.BranchNode

	// CommitmentBlock is the block that contains the commitment to the
	// asset supply. This may be None if the commitment has not yet
	// been mined.
	CommitmentBlock fn.Option[CommitmentBlock]

	// SpentCommitment is the outpoint of the previous root commitment that
	// this root commitment is spending. This will be None if this is the
	// first root commitment for the asset.
	SpentCommitment fn.Option[wire.OutPoint]
}

type SignTxEvent struct {
	// CommitPkt is the unsigned transaction that will be used to commit to
	// the new supply tree.
	CommitPkt *tapsend.FundedPsbt

	// NewSupplyCommit is the new supply commitment that that will be
	// created by the above commit pkt.
	NewSupplyCommit RootCommitment
}

type SpendEvent struct {
	// Tx is the spending transaction that has been confirmed.
	Tx *wire.MsgTx

	// BlockHeight is the height of the block that confirmed the
	// transaction.
	BlockHeight uint32
}

type SpendMapper = protofsm.SpendMapper[Event]

type State interface {

	// IsTerminal returns true if the target state is a terminal state.
	IsTerminal() bool

	// ProcessEvent takes a supply event event, and implements a state
	// transition for the state.
	//
	// nolint:lll
	ProcessEvent(Event, *Environment) (*StateTransition, error)

	// String returns the name of the state.
	String() string
	// contains filtered or unexported methods
}

type StateMachine = protofsm.StateMachine[Event, *Environment]

type StateMachineStore interface {
	// InsertPendingUpdate attempts to insert a new pending update into the
	// update log of the target supply commit state machine. If the state
	// machine doesn't yet exist, then it will be created at the
	// UpdatesPendingState. If the state machine exists, but is in a
	// different state then UpdatesPendingState, then an error will be
	// returned.
	//
	// This method will also create a new pending SupplyStateTransition.
	InsertPendingUpdate(context.Context, asset.Specifier,
		SupplyUpdateEvent) error

	// InsertSignedCommitTx will associated a new signed commitment
	// anchor transaction with the current active supply commitment state
	// transition. This'll update the existing funded txn with a signed
	// copy. Finally the state of the  supply commit state transition will
	// transition to CommitBroadcastState.
	InsertSignedCommitTx(context.Context, asset.Specifier,
		SupplyCommitTxn) error

	// CommitState is used to commit the state of the state machine to then
	// disk.
	CommitState(context.Context, asset.Specifier, State) error

	// FetchState attempts to fetch the state of the state machine for the
	// target asset specifier. If the state machine doesn't exist, then an
	// error will be returned.
	//
	// TODO(roasbeef): also have it return the next event if exists?
	FetchState(context.Context, asset.Specifier) (State,
		lfn.Option[SupplyStateTransition], error)

	// ApplyStateTransition is used to apply a new state transition to the
	// target state machine. Once the transition has been applied, the state
	// machine will transition back to the default state.
	//
	// To apply a state transition, the following operations must be carried
	// out:
	//   * Insert the set of PendingUpdates into their respective sub supply
	//   trees.
	//   * Insert the new supply try leaves into the universe supply root.
	//   * Update the current supply commitment with the target chain
	//     transaction (output index, etc).
	//   * Update the block height and merkle proof information.
	//   * Update the internal key and output key of the commitment
	//     transaction.
	//   * Update the target state machine to the Default state.
	//   * Mark the target state transition as finalized.
	ApplyStateTransition(context.Context, asset.Specifier,
		SupplyStateTransition) error

	// FreezePendingTransition marks the current pending transition for a
	// group key as frozen.
	FreezePendingTransition(context.Context, asset.Specifier) error

	// BindDanglingUpdatesToTransition finds any supply update events for
	// the given asset specifier that are not yet associated with a
	// transition, creates a new transition for them, and links them. It
	// returns the list of events that were bound. If no dangling events are
	// found, it returns an empty slice and no error.
	BindDanglingUpdatesToTransition(context.Context,
		asset.Specifier) ([]SupplyUpdateEvent, error)
}

type StateSub = protofsm.StateSubscriber[Event, *Environment]

type StateTransition = protofsm.StateTransition[Event, *Environment]

type SubtreeRootProof struct {
	// Type indicates the type of the supply commit subtree.
	Type SupplySubTree

	// RootNode is the root node of the supply commit subtree.
	RootNode mssmt.BranchNode

	// SupplyTreeLeafKey locates the subtree leaf node in the supply commit
	// tree.
	SupplyTreeLeafKey universe.UniverseKey

	// SupplyTreeInclusionProof proves inclusion of the subtree root in the
	// supply tree.
	SupplyTreeInclusionProof mssmt.Proof
}

type SupplyCommitTxn struct {
	// Txn is the transaction that creates the supply commitment.
	Txn *wire.MsgTx

	// InternalKey is the internal key descriptor used for the commitment
	// output. This preserves the full key derivation information.
	InternalKey keychain.KeyDescriptor

	// OutputKey is the taproot output key used for the commitment output.
	OutputKey *btcec.PublicKey

	// OutputIndex is the index of the commitment output within the Txn.
	OutputIndex uint32
}

type SupplyLeaves struct {
	// IssuanceLeafEntries is a slice of issuance leaves.
	IssuanceLeafEntries []NewMintEvent

	// BurnLeafEntries is a slice of burn leaves.
	BurnLeafEntries []NewBurnEvent

	// IgnoreLeafEntries is a slice of ignore leaves.
	IgnoreLeafEntries []NewIgnoreEvent
}

type SupplyStateTransition struct {
	// OldCommitment is the old commitment that is being spent. This is used
	// to create the new commitment output (by spending this input).
	OldCommitment lfn.Option[RootCommitment]

	// UnspentPreCommits is the set of unspent pre-commitments that are
	// unspent. These will also be used as input into the new commit txn.
	UnspentPreCommits []PreCommitment

	// PendingUpdates is the set of new updates that are being added to the
	// commitment. These are the new mints, burns, or ignores.
	PendingUpdates []SupplyUpdateEvent

	// NewCommitment is the new commitment that is being created.
	//
	// TODO(roasbeef): opt? may not exist before pending updates added
	NewCommitment RootCommitment

	// ChainProof is the chain proof that proves that the new commitment has
	// been mined in the Bitcoin blockchain. If None, then the commitment
	// has not yet been mined.
	ChainProof lfn.Option[ChainProof]
}

type SupplySubTree uint8

type SupplySyncer interface {
	// PushSupplyCommitment pushes a supply commitment to the remote
	// universe server. This function should block until the sync insertion
	// is complete.
	//
	// Returns a map of per-server errors keyed by server host string and
	// an internal error. If all pushes succeed, both return values are nil.
	// If some pushes fail, the map contains only the failed servers and
	// their corresponding errors. If there's an internal/system error that
	// prevents the operation from proceeding, it's returned as the second
	// value.
	PushSupplyCommitment(ctx context.Context, assetSpec asset.Specifier,
		commitment RootCommitment, updateLeaves SupplyLeaves,
		chainProof ChainProof,
		canonicalUniverses []url.URL) (map[string]error, error)
}

type SupplyTreeView interface {
	// FetchSubTree returns the sub tree for the given asset spec. This
	// instance returned should be a copy, as mutations make take place in
	// the tree.
	FetchSubTree(ctx context.Context, assetSpec asset.Specifier,
		treeType SupplySubTree) lfn.Result[mssmt.Tree]

	// FetchSubTrees returns all the subtrees for the given asset spec.
	FetchSubTrees(ctx context.Context,
		assetSpec asset.Specifier,
		blockHeightEnd fn.Option[uint32]) lfn.Result[SupplyTrees]

	// FetchRootSupplyTree returns the root supply tree which contains a
	// commitment to each of the sub trees.
	FetchRootSupplyTree(ctx context.Context,
		assetSpec asset.Specifier) lfn.Result[mssmt.Tree]

	// FetchSupplyLeavesByHeight returns the set of supply leaves for the
	// given asset specifier within the specified height range.
	FetchSupplyLeavesByHeight(ctx context.Context,
		assetSpec asset.Specifier, startHeight,
		endHeight uint32) lfn.Result[SupplyLeaves]
}

type SupplyTrees map[SupplySubTree]mssmt.Tree

type SupplyUpdateEvent interface {
	Event

	// ScriptKey returns the script key that is used to identify the target
	// asset.
	ScriptKey() asset.SerializedKey

	// SupplySubTreeType returns the type of sub-tree this update affects.
	SupplySubTreeType() SupplySubTree

	// UniverseLeafKey returns the specific leaf key to use when inserting
	// this update into a universe supply MS-SMT tree.
	UniverseLeafKey() universe.UniqueLeafKey

	// UniverseLeafNode returns the leaf node to use when inserting this
	// update into a universe supply MS-SMT tree.
	UniverseLeafNode() (*mssmt.LeafNode, error)

	// BlockHeight returns the block height of the update.
	BlockHeight() uint32

	// Encode encodes the event into the passed io.Writer.
	Encode(io.Writer) error
}

type SyncSupplyUpdateEvent interface {
	SupplyUpdateEvent

	// SignalDone signals completion on the done channel if it exists.
	// It sends the error (or nil for success) and does not block.
	SignalDone(error)

	// WaitForDone waits for the event to be processed by waiting on its
	// done channel. This is a helper method that can be used by callers who
	// want synchronous confirmation that their event has been persisted.
	WaitForDone(context.Context) error
}

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

type Wallet interface {
	// FundPsbt attaches enough inputs to the target PSBT packet for it to
	// be valid.
	FundPsbt(ctx context.Context, packet *psbt.Packet, minConfs uint32,
		feeRate chainfee.SatPerKWeight,
		changeIdx int32) (*tapsend.FundedPsbt, error)

	// SignPsbt fully signs the target PSBT packet.
	SignPsbt(context.Context, *psbt.Packet) (*psbt.Packet, error)

	// ImportTaprootOutput imports a new taproot output key into the wallet.
	ImportTaprootOutput(context.Context, *btcec.PublicKey) (btcutil.Address,
		error)

	// UnlockInput unlocks the set of target inputs after a batch or send
	// transaction is abandoned.
	UnlockInput(context.Context, wire.OutPoint) error
}