tapgarden

type AssetMetas map[asset.SerializedKey]*proof.MetaReveal

type AssetReceiveCompleteEvent struct {

	// Address is the address associated with the asset that was received.
	Address address.Tap

	// OutPoint is the outpoint of the transaction that was used to receive
	// the asset.
	OutPoint wire.OutPoint
	// contains filtered or unexported fields
}

type BatchCaretaker 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 BatchCaretakerConfig struct {
	// Batch is the minting batch that this caretaker is responsible for?
	Batch *MintingBatch

	// BatchFeeRate is an optional manually-set feerate specified when
	// finalizing a batch.
	BatchFeeRate *chainfee.SatPerKWeight

	GardenKit

	// BroadcastCompleteChan is used to signal back to the caller that the
	// batch has been broadcast and is now waiting for confirmation. Either
	// this channel _or_ BroadcastErrChan is sent on, never both.
	BroadcastCompleteChan chan struct{}

	// BroadcastErrChan is used to signal back to the caller that while
	// attempting to proceed the batch to the state of broadcasting the
	// batch transaction, an error occurred. Either this channel _or_
	// BroadcastCompleteChan is sent on, never both.
	BroadcastErrChan chan error

	// SignalCompletion is used to signal back to the BatchPlanter that
	// their batch has been finalized.
	SignalCompletion func()

	// CancelChan is used by the BatchPlanter to signal that the caretaker
	// should stop advancing the batch.
	CancelReqChan chan struct{}

	// CancelRespChan is used by the BatchCaretaker to report the result of
	// attempted batch cancellation to the planter.
	CancelRespChan chan CancelResp

	// UpdateMintingProofs is used to update the minting proofs in the
	// database in case of a re-org. This cannot be done by the caretaker
	// itself, because its job is already done at the point that a re-org
	// can happen (the batch is finalized after a single confirmation).
	UpdateMintingProofs func([]*proof.Proof) error

	// ErrChan is the main error channel the caretaker will report back
	// critical errors to the main server.
	ErrChan chan<- error
}

type BatchKey = asset.SerializedKey

type BatchState uint8

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

type ChainBridge interface {
	// RegisterConfirmationsNtfn registers an intent to be notified once
	// txid reaches numConfs confirmations.
	RegisterConfirmationsNtfn(ctx context.Context, txid *chainhash.Hash,
		pkScript []byte, numConfs, heightHint uint32,
		includeBlock bool,
		reOrgChan chan struct{}) (*chainntnfs.ConfirmationEvent,
		chan error, error)

	// RegisterBlockEpochNtfn registers an intent to be notified of each
	// new block connected to the main chain.
	RegisterBlockEpochNtfn(ctx context.Context) (chan int32, chan error,
		error)

	// GetBlock returns a chain block given its hash.
	GetBlock(context.Context, chainhash.Hash) (*wire.MsgBlock, error)

	// GetBlockHash returns the hash of the block in the best blockchain at
	// the given height.
	GetBlockHash(context.Context, int64) (chainhash.Hash, error)

	// VerifyBlock returns an error if a block (with given header and
	// height) is not present on-chain. It also checks to ensure that block
	// height corresponds to the given block header.
	VerifyBlock(ctx context.Context, header wire.BlockHeader,
		height uint32) error

	// CurrentHeight return the current height of the main chain.
	CurrentHeight(context.Context) (uint32, error)

	// PublishTransaction attempts to publish a new transaction to the
	// network.
	PublishTransaction(context.Context, *wire.MsgTx) error

	// EstimateFee returns a fee estimate for the confirmation target.
	EstimateFee(ctx context.Context,
		confTarget uint32) (chainfee.SatPerKWeight, error)
}

type ChainPlanter 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 Custodian 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 CustodianConfig struct {
	// ChainParams are the Taproot Asset specific chain parameters.
	ChainParams *address.ChainParams

	// WalletAnchor is the main interface for interacting with the on-chain
	// wallet.
	WalletAnchor WalletAnchor

	// ChainBridge is the main interface for interacting with the chain
	// backend.
	ChainBridge ChainBridge

	// GroupVerifier is used to verify the validity of the group key for an
	// asset.
	GroupVerifier proof.GroupVerifier

	// AddrBook is the storage backend for addresses.
	AddrBook *address.Book

	// ProofArchive is the storage backend for proofs to which we store new
	// incoming proofs.
	ProofArchive proof.Archiver

	// ProofNotifier is the storage backend for proofs from which we are
	// notified about new proofs. This can be the same as the ProofArchive
	// above but can also be different (for example if we should _store_ the
	// proofs to a multi archiver but only be notified about new proofs
	// being available in the relational database).
	ProofNotifier proof.NotifyArchiver

	// ProofCourierDispatcher is the dispatcher that is used to create new
	// proof courier handles for receiving proofs based on the protocol of
	// a proof courier address.
	ProofCourierDispatcher proof.CourierDispatch

	// ProofRetrievalDelay is the time duration the custodian waits having
	// identified an asset transfer on-chain and before retrieving the
	// corresponding proof via the proof courier service.
	ProofRetrievalDelay time.Duration

	// ProofWatcher is used to watch new proofs for their anchor transaction
	// to be confirmed safely with a minimum number of confirmations.
	ProofWatcher proof.Watcher

	// ErrChan is the main error channel the custodian will report back
	// critical errors to the main server.
	ErrChan chan<- error
}

type FundedPsbt struct {
	// Pkt is the PSBT packet itself.
	Pkt *psbt.Packet

	// ChangeOutputIndex denotes which output in the PSBT packet is the
	// change output. We use this to figure out which output will store our
	// Taproot Asset commitment (the non-change output).
	ChangeOutputIndex int32

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

	// LockedUTXOs is the set of UTXOs that were locked to create the PSBT
	// packet.
	LockedUTXOs []wire.OutPoint
}

type GardenKit struct {
	// Wallet is an active on chain wallet for the target chain.
	Wallet WalletAnchor

	// ChainBridge provides access to the chain for confirmation
	// notification, and other block related actions.
	ChainBridge ChainBridge

	// Log stores the current state of any active batch, throughout the
	// various states the planter will progress it through.
	Log MintingStore

	// KeyRing is used for obtaining internal keys for the anchor
	// transaction, as well as script keys for each asset and group keys
	// for assets created that permit ongoing emission.
	KeyRing KeyRing

	// GenSigner is used to generate signatures for the key group tweaked
	// by the genesis point when creating assets that permit on going
	// emission.
	GenSigner asset.GenesisSigner

	// GenTxBuilder is used to create virtual transactions for the group
	// witness generation process.
	GenTxBuilder asset.GenesisTxBuilder

	// TxValidator is used to validate group witnesses when creating assets
	// that support reissuance.
	TxValidator tapscript.TxValidator

	// ProofFiles stores the set of flat proof files.
	ProofFiles proof.Archiver

	// Universe is used to register new asset issuance with a local/remote
	// base universe instance.
	Universe universe.BatchRegistrar

	// ProofWatcher is used to watch new proofs for their anchor transaction
	// to be confirmed safely with a minimum number of confirmations.
	ProofWatcher proof.Watcher

	// UniversePushBatchSize is the number of minted items to push to the
	// local universe in a single batch.
	UniversePushBatchSize int
}

type KeyRing interface {
	// DeriveNextKey attempts to derive the *next* key within the key
	// family (account in BIP-0043) specified. This method should return the
	// next external child within this branch.
	DeriveNextKey(context.Context,
		keychain.KeyFamily) (keychain.KeyDescriptor, error)

	// DeriveKey attempts to derive an arbitrary key specified by the
	// passed KeyLocator. This may be used in several recovery scenarios,
	// or when manually rotating something like our current default node
	// key.
	DeriveKey(context.Context,
		keychain.KeyLocator) (keychain.KeyDescriptor, error)

	// IsLocalKey returns true if the key is under the control of the wallet
	// and can be derived by it.
	IsLocalKey(context.Context, keychain.KeyDescriptor) bool
}

type MintingBatch struct {
	// CreationTime is the time that this batch was created.
	CreationTime time.Time

	// HeightHint is the recorded block height at time of creating this
	// batch. We use it to know where to start looking for the signed batch
	// transaction.
	HeightHint uint32

	// BatchKey is the unique identifier for a batch.
	BatchKey keychain.KeyDescriptor

	// Seedlings is the set of seedlings for this batch. This maps an
	// asset's name to the seedling itself.
	//
	// NOTE: This field is only set if the state is BatchStateFrozen or
	// BatchStatePending.
	Seedlings map[string]*Seedling

	// GenesisPacket is the funded genesis packet that may or may not be
	// fully signed. When broadcast, this will create all assets stored
	// within this batch.
	//
	// NOTE: This field is only set if the state is beyond
	// BatchStateCommitted.
	GenesisPacket *FundedPsbt

	// RootAssetCommitment is the root Taproot Asset commitment for all the
	// assets contained in this batch.
	//
	// NOTE: This field is only set if the state is beyond
	// BatchStateCommitted.
	RootAssetCommitment *commitment.TapCommitment

	// AssetMetas maps the serialized script key of an asset to the meta
	// reveal for that asset, if it has one.
	AssetMetas AssetMetas
	// contains filtered or unexported fields
}

type MintingState uint8

type MintingStore interface {
	// CommitMintingBatch commits a new minting batch to disk, identified
	// by its batch key.
	CommitMintingBatch(ctx context.Context, newBatch *MintingBatch) error

	// UpdateBatchState updates the batch state on disk identified by the
	// batch key.
	UpdateBatchState(ctx context.Context, batchKey *btcec.PublicKey,
		newState BatchState) error

	// AddSeedlingsToBatch adds a new seedling to an existing batch. Once
	// added this batch should remain in the BatchStatePending state.
	//
	// TODO(roasbeef): assumption that only one pending batch at a time?
	AddSeedlingsToBatch(ctx context.Context, batchKey *btcec.PublicKey,
		seedlings ...*Seedling) error

	// FetchAllBatches fetches all the batches on disk.
	FetchAllBatches(ctx context.Context) ([]*MintingBatch, error)

	// FetchNonFinalBatches fetches all non-finalized batches, meaning
	// batches that haven't yet fully confirmed on chain.
	FetchNonFinalBatches(ctx context.Context) ([]*MintingBatch, error)

	// FetchMintingBatch is used to fetch a single minting batch specified
	// by the batch key.
	FetchMintingBatch(ctx context.Context,
		batchKey *btcec.PublicKey) (*MintingBatch, error)

	// AddSproutsToBatch adds a new set of sprouts to the batch, along with
	// a GenesisPacket, that once signed and broadcast with create the
	// set of assets on chain.
	//
	// NOTE: The BatchState should transition to BatchStateCommitted upon a
	// successful call.
	AddSproutsToBatch(ctx context.Context, batchKey *btcec.PublicKey,
		genesisPacket *FundedPsbt, assets *commitment.TapCommitment) error

	// CommitSignedGenesisTx adds a fully signed genesis transaction to the
	// batch, along with the Taproot Asset script root, which is the
	// left/right sibling for the Taproot Asset tapscript commitment in the
	// transaction.
	//
	// NOTE: The BatchState should transition to the BatchStateBroadcast
	// state upon a successful call.
	CommitSignedGenesisTx(ctx context.Context, batchKey *btcec.PublicKey,
		genesisTx *FundedPsbt, anchorOutputIndex uint32,
		tapRoot []byte) error

	// MarkBatchConfirmed marks the batch as confirmed on chain. The passed
	// block location information determines where exactly in the chain the
	// batch was confirmed.
	//
	// NOTE: The BatchState should transition to the BatchStateConfirmed
	// state upon a successful call.
	MarkBatchConfirmed(ctx context.Context, batchKey *btcec.PublicKey,
		blockHash *chainhash.Hash, blockHeight uint32,
		txIndex uint32, mintingProofs proof.AssetBlobs) error

	// FetchGroupByGenesis fetches the asset group created by the genesis
	// referenced by the given ID.
	FetchGroupByGenesis(ctx context.Context,
		genesisID int64) (*asset.AssetGroup, error)

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

type MockAssetSyncer struct {
	Assets map[asset.ID]*asset.AssetGroup

	FetchedAssets chan *asset.AssetGroup

	FetchErrs bool
}

type MockChainBridge struct {
	FeeEstimateSignal chan struct{}
	PublishReq        chan *wire.MsgTx
	ConfReqSignal     chan int
	BlockEpochSignal  chan struct{}

	NewBlocks chan int32

	ReqCount int
	ConfReqs map[int]*chainntnfs.ConfirmationEvent
}

type MockGenSigner struct {
	KeyRing *MockKeyRing
}

type MockKeyRing struct {
	FamIndex keychain.KeyFamily
	KeyIndex uint32

	Keys map[keychain.KeyLocator]*btcec.PrivateKey

	ReqKeys chan *keychain.KeyDescriptor
}

type MockProofArchive struct {
}

type MockProofWatcher struct {
}

type MockWalletAnchor struct {
	FundPsbtSignal     chan *FundedPsbt
	SignPsbtSignal     chan struct{}
	ImportPubKeySignal chan *btcec.PublicKey
	ListUnspentSignal  chan struct{}
	SubscribeTxSignal  chan struct{}
	SubscribeTx        chan lndclient.Transaction
	ListTxnsSignal     chan struct{}

	Transactions  []lndclient.Transaction
	ImportedUtxos []*lnwallet.Utxo
}

type Planter interface {
	// QueueNewSeedling attempts to queue a new seedling request (the
	// intent for New asset creation or ongoing issuance) to the Planter.
	// A channel is returned where future updates will be sent over. If an
	// error is returned no issuance operation was possible.
	QueueNewSeedling(req *Seedling) (SeedlingUpdates, error)

	// ListBatches lists the set of batches submitted for minting, or the
	// details of a specific batch.
	ListBatches(batchKey *btcec.PublicKey) ([]*MintingBatch, error)

	// CancelSeedling attempts to cancel the creation of a new asset
	// identified by its name. If the seedling has already progressed to a
	// point where the genesis PSBT has been broadcasted, an error is
	// returned.
	CancelSeedling() error

	// FinalizeBatch signals that the asset minter should finalize
	// the current batch, if one exists.
	FinalizeBatch(feeRate *chainfee.SatPerKWeight) (*MintingBatch, error)

	// CancelBatch signals that the asset minter should cancel the
	// current batch, if one exists.
	CancelBatch() (*btcec.PublicKey, error)

	// Start signals that the asset minter should being operations.
	Start() error

	// Stop signals that the asset minter should attempt a graceful
	// shutdown.
	Stop() error
}

type PlanterConfig struct {
	GardenKit

	// BatchTicker is used to notify the planter than it should assemble
	// all asset requests into a new batch.
	BatchTicker *ticker.Force

	// ProofUpdates is the storage backend for updated proofs.
	ProofUpdates proof.Archiver

	// ErrChan is the main error channel the planter will report back
	// critical errors to the main server.
	ErrChan chan<- error
}

type ReOrgWatcher 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 ReOrgWatcherConfig struct {
	// ChainBridge is the main interface for interacting with the chain
	// backend.
	ChainBridge ChainBridge

	// GroupVerifier is used to verify the validity of the group key for an
	// asset.
	GroupVerifier proof.GroupVerifier

	// ProofArchive is the storage backend for proofs to which we store
	// updated proofs.
	ProofArchive proof.Archiver

	// NonBuriedAssetFetcher is a function that returns all assets that are
	// not yet sufficiently deep buried.
	NonBuriedAssetFetcher func(ctx context.Context,
		minHeight int32) ([]*asset.ChainAsset, error)

	// SafeDepth is the number of confirmations we require before we
	// consider a transaction to be safely buried in the chain.
	SafeDepth int32

	// ErrChan is the main error channel the watcher will report back
	// critical errors to the main server.
	ErrChan chan<- error
}

type Seedling struct {
	// AssetVersion is the version of the asset to be created.
	AssetVersion asset.Version

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

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

	// Meta is the set of metadata associated with the asset.
	Meta *proof.MetaReveal

	// Amount is the total amount of the asset.
	Amount uint64

	// GroupInfo contains the information needed to link this asset to an
	// exiting group.
	GroupInfo *asset.AssetGroup

	// EnableEmission if true, then an asset group key will be specified
	// for this asset meaning future assets linked to it can be created.
	EnableEmission bool

	// GroupAnchor is the name of another seedling in the pending batch that
	// will anchor an asset group. This seedling will be minted with the
	// same group key as the anchor asset.
	GroupAnchor *string
	// contains filtered or unexported fields
}

type SeedlingUpdate struct {
	// NewState is the new state a seedling has transitioned to.
	NewState MintingState

	// PendingBatch is the current pending batch that the seedling has been
	// added to.
	PendingBatch *MintingBatch

	// Error if non-nil, denotes that an terminal error state has been
	// reached.
	Error error
}

type SeedlingUpdates chan SeedlingUpdate

type WalletAnchor 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) (FundedPsbt, error)

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

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

	// UnlockInput unlocks the set of target inputs after a batch is
	// abandoned.
	UnlockInput(context.Context) error

	// ListUnspentImportScripts lists all UTXOs of the imported Taproot
	// scripts.
	ListUnspentImportScripts(ctx context.Context) ([]*lnwallet.Utxo, error)

	// ListTransactions returns all known transactions of the backing lnd
	// node. It takes a start and end block height which can be used to
	// limit the block range that we query over. These values can be left
	// as zero to include all blocks. To include unconfirmed transactions
	// in the query, endHeight must be set to -1.
	ListTransactions(ctx context.Context, startHeight, endHeight int32,
		account string) ([]lndclient.Transaction, error)

	// SubscribeTransactions creates a uni-directional stream from the
	// server to the client in which any newly discovered transactions
	// relevant to the wallet are sent over.
	SubscribeTransactions(context.Context) (<-chan lndclient.Transaction,
		<-chan error, error)
}