tapdb

type ActiveAssetsStore interface {
	// UpsertAssetStore houses the methods related to inserting/updating
	// assets.
	UpsertAssetStore

	// QueryAssets fetches the set of fully confirmed assets.
	QueryAssets(context.Context, QueryAssetFilters) ([]ConfirmedAsset,
		error)

	// QueryAssetBalancesByAsset queries the balances for assets or
	// alternatively for a selected one that matches the passed asset ID
	// filter.
	QueryAssetBalancesByAsset(context.Context, []byte) ([]RawAssetBalance,
		error)

	// QueryAssetBalancesByGroup queries the asset balances for asset
	// groups or alternatively for a selected one that matches the passed
	// filter.
	QueryAssetBalancesByGroup(context.Context,
		[]byte) ([]RawAssetGroupBalance, error)

	// FetchGroupedAssets fetches all assets with non-nil group keys.
	FetchGroupedAssets(context.Context) ([]RawGroupedAsset, error)

	// FetchAssetProofs fetches all the asset proofs we have stored on
	// disk.
	FetchAssetProofs(ctx context.Context) ([]AssetProof, error)

	// FetchAssetProof fetches the asset proof for a given asset identified
	// by its script key.
	FetchAssetProof(ctx context.Context,
		arg FetchAssetProof) ([]AssetProofI, error)

	// HasAssetProof returns true if we have proof for a given asset
	// identified by its script key.
	HasAssetProof(ctx context.Context, scriptKey []byte) (bool, error)

	// FetchAssetProofsByAssetID fetches all asset proofs for a given asset
	// ID.
	FetchAssetProofsByAssetID(ctx context.Context,
		assetID []byte) ([]AssetProofByIDRow, error)

	// UpsertChainTx inserts a new or updates an existing chain tx into the
	// DB.
	UpsertChainTx(ctx context.Context, arg ChainTxParams) (int64, error)

	// FetchChainTx fetches a chain tx from the DB.
	FetchChainTx(ctx context.Context, txid []byte) (ChainTx, error)

	// UpsertManagedUTXO inserts a new or updates an existing managed UTXO
	// to disk and returns the primary key.
	UpsertManagedUTXO(ctx context.Context, arg RawManagedUTXO) (int64,
		error)

	// UpsertAssetProof inserts a new or updates an existing asset proof on
	// disk.
	UpsertAssetProof(ctx context.Context, arg ProofUpdate) error

	// UpsertAssetProofByID inserts a new or updates an existing asset
	// proof on disk.
	UpsertAssetProofByID(ctx context.Context, arg ProofUpdateByID) error

	// UpsertAssetWitness upserts a new prev input for an asset into the
	// database.
	UpsertAssetWitness(context.Context, PrevInput) error

	// FetchAssetWitnesses attempts to fetch either all the asset witnesses
	// on disk (NULL param), or the witness for a given asset ID.
	FetchAssetWitnesses(context.Context, sql.NullInt64) ([]AssetWitness,
		error)

	// FetchManagedUTXO fetches a managed UTXO based on either the outpoint
	// or the transaction that anchors it.
	FetchManagedUTXO(context.Context, UtxoQuery) (AnchorPoint, error)

	// FetchManagedUTXOs fetches all managed UTXOs.
	FetchManagedUTXOs(context.Context) ([]ManagedUTXORow, error)

	// ApplyPendingOutput applies a transfer output (new amount and script
	// key) based on the existing script key of an asset.
	ApplyPendingOutput(ctx context.Context, arg ApplyPendingOutput) (int64,
		error)

	// DeleteManagedUTXO deletes the managed utxo identified by the passed
	// serialized outpoint.
	DeleteManagedUTXO(ctx context.Context, outpoint []byte) error

	// UpdateUTXOLease leases a managed UTXO identified by the passed
	// serialized outpoint.
	UpdateUTXOLease(ctx context.Context, arg UpdateUTXOLease) error

	// DeleteUTXOLease deletes the lease on a managed UTXO identified by
	// the passed serialized outpoint.
	DeleteUTXOLease(ctx context.Context, outpoint []byte) error

	// DeleteExpiredUTXOLeases deletes all expired UTXO leases.
	DeleteExpiredUTXOLeases(ctx context.Context, now sql.NullTime) error

	// ConfirmChainAnchorTx marks a new anchor transaction that was
	// previously unconfirmed as confirmed.
	ConfirmChainAnchorTx(ctx context.Context, arg AnchorTxConf) error

	// InsertAssetTransfer inserts a new asset transfer into the DB.
	InsertAssetTransfer(ctx context.Context,
		arg NewAssetTransfer) (int64, error)

	// InsertAssetTransferInput inserts a new asset transfer input into the
	// DB.
	InsertAssetTransferInput(ctx context.Context,
		arg NewTransferInput) error

	// InsertAssetTransferOutput inserts a new asset transfer output into
	// the DB.
	InsertAssetTransferOutput(ctx context.Context,
		arg NewTransferOutput) error

	// FetchTransferInputs fetches the inputs to a given asset transfer.
	FetchTransferInputs(ctx context.Context,
		transferID int64) ([]TransferInputRow, error)

	// FetchTransferOutputs fetches the outputs to a given asset transfer.
	FetchTransferOutputs(ctx context.Context,
		transferID int64) ([]TransferOutputRow, error)

	// QueryAssetTransfers queries for a set of asset transfers in the db.
	QueryAssetTransfers(ctx context.Context,
		query sqlc.QueryAssetTransfersParams) ([]AssetTransferRow,
		error)

	// DeleteAssetWitnesses deletes the witnesses on disk associated with a
	// given asset ID.
	DeleteAssetWitnesses(ctx context.Context, assetID int64) error

	// LogProofTransferAttempt logs a new proof transfer attempt.
	LogProofTransferAttempt(ctx context.Context,
		arg LogProofTransAttemptParams) error

	// QueryProofTransferAttempts returns timestamps from the proof transfer
	// attempts log.
	QueryProofTransferAttempts(ctx context.Context,
		arg QueryProofTransAttemptsParams) ([]time.Time, error)

	// InsertPassiveAsset inserts a new row which includes the data
	// necessary to re-anchor a passive asset.
	InsertPassiveAsset(ctx context.Context, arg NewPassiveAsset) error

	// QueryPassiveAssets returns the data required to re-anchor
	// pending passive assets that are anchored at the given outpoint.
	QueryPassiveAssets(ctx context.Context,
		transferID int64) ([]PassiveAsset, error)

	// ReAnchorPassiveAssets re-anchors the passive assets identified by
	// the passed params.
	ReAnchorPassiveAssets(ctx context.Context, arg ReAnchorParams) error

	// FetchAssetMetaByHash fetches the asset meta for a given meta hash.
	//
	// TODO(roasbeef): split into MetaStore?
	FetchAssetMetaByHash(ctx context.Context,
		metaDataHash []byte) (sqlc.FetchAssetMetaByHashRow, error)

	// FetchAssetMetaForAsset fetches the asset meta for a given asset.
	FetchAssetMetaForAsset(ctx context.Context,
		assetID []byte) (sqlc.FetchAssetMetaForAssetRow, error)
}

type AddrBook interface {
	// UpsertAssetStore houses the methods related to inserting/updating
	// assets.
	UpsertAssetStore

	// GroupStore houses the methods related to fetching genesis assets and
	// asset groups related to them.
	GroupStore

	// FetchAddrs returns all the addresses based on the constraints of the
	// passed AddrQuery.
	FetchAddrs(ctx context.Context, arg AddrQuery) ([]Addresses, error)

	// FetchAddrByTaprootOutputKey returns a single address based on its
	// Taproot output key or a sql.ErrNoRows error if no such address
	// exists.
	FetchAddrByTaprootOutputKey(ctx context.Context,
		arg []byte) (AddrByTaprootOutput, error)

	// InsertAddr inserts a new address into the database.
	InsertAddr(ctx context.Context, arg NewAddr) (int64, error)

	// UpsertInternalKey inserts a new or updates an existing internal key
	// into the database and returns the primary key.
	UpsertInternalKey(ctx context.Context, arg InternalKey) (int64, error)

	// UpsertScriptKey inserts a new script key on disk into the DB.
	UpsertScriptKey(context.Context, NewScriptKey) (int64, error)

	// SetAddrManaged sets an address as being managed by the internal
	// wallet.
	SetAddrManaged(ctx context.Context, arg AddrManaged) error

	// UpsertManagedUTXO inserts a new or updates an existing managed UTXO
	// to disk and returns the primary key.
	UpsertManagedUTXO(ctx context.Context, arg RawManagedUTXO) (int64,
		error)

	// UpsertChainTx inserts a new or updates an existing chain tx into the
	// DB.
	UpsertChainTx(ctx context.Context, arg ChainTxParams) (int64, error)

	// UpsertAddrEvent inserts a new or updates an existing address event
	// and returns the primary key.
	UpsertAddrEvent(ctx context.Context, arg UpsertAddrEvent) (int64, error)

	// FetchAddrEvent returns a single address event based on its primary
	// key.
	FetchAddrEvent(ctx context.Context, id int64) (AddrEvent, error)

	// QueryEventIDs returns a list of event IDs and their corresponding
	// address IDs that match the given query parameters.
	QueryEventIDs(ctx context.Context, query AddrEventQuery) ([]AddrEventID,
		error)

	// FetchAssetProof fetches the asset proof for a given asset identified
	// by its script key.
	FetchAssetProof(ctx context.Context,
		arg FetchAssetProof) ([]AssetProofI, error)

	// FetchGenesisByAssetID attempts to fetch asset genesis information
	// for a given asset ID.
	FetchGenesisByAssetID(ctx context.Context,
		assetID []byte) (sqlc.GenesisInfoView, error)

	// FetchScriptKeyByTweakedKey attempts to fetch the script key and
	// corresponding internal key from the database.
	FetchScriptKeyByTweakedKey(ctx context.Context,
		tweakedScriptKey []byte) (ScriptKey, error)
}

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

type AddrByTaprootOutput = sqlc.FetchAddrByTaprootOutputKeyRow

type AddrEvent = sqlc.FetchAddrEventRow

type AddrEventID = sqlc.QueryEventIDsRow

type AddrEventQuery = sqlc.QueryEventIDsParams

type AddrManaged = sqlc.SetAddrManagedParams

type AddrQuery = sqlc.FetchAddrsParams

type Addresses = sqlc.FetchAddrsRow

type AggregateStats = sqlc.QueryUniverseStatsRow

type AnchorPoint = sqlc.FetchManagedUTXORow

type AnchorTxConf = sqlc.ConfirmChainAnchorTxParams

type ApplyPendingOutput = sqlc.ApplyPendingOutputParams

type AssetAnchor = sqlc.AnchorPendingAssetsParams

type AssetBalance struct {
	ID           asset.ID
	Version      int32
	Balance      uint64
	Tag          string
	MetaHash     [asset.MetaHashLen]byte
	Type         asset.Type
	GenesisPoint wire.OutPoint
	OutputIndex  uint32
}

type AssetGroupBalance struct {
	GroupKey *btcec.PublicKey
	Balance  uint64
}

type AssetGroupKey = sqlc.UpsertAssetGroupKeyParams

type AssetGroupWitness = sqlc.UpsertAssetGroupWitnessParams

type AssetHumanReadable struct {
	// ID is the unique identifier for the asset.
	ID asset.ID

	// Version is the version of the asset.
	Version asset.Version

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

	// LockTime, if non-zero, restricts an asset from being moved prior to
	// the represented block height in the chain.
	LockTime uint64

	// RelativeLockTime, if non-zero, restricts an asset from being moved
	// until a number of blocks after the confirmation height of the latest
	// transaction for the asset is reached.
	RelativeLockTime uint64

	// Tag is the human-readable identifier for the asset.
	Tag string

	// MetaHash is the hash of the meta data for this asset.
	MetaHash [asset.MetaHashLen]byte

	// Type uniquely identifies the type of Taproot asset.
	Type asset.Type

	// GroupKey is the tweaked public key that is used to associate assets
	// together across distinct asset IDs.
	GroupKey *btcec.PublicKey
}

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

type AssetProof = sqlc.FetchAssetProofsRow

type AssetProofByIDRow = sqlc.FetchAssetProofsByAssetIDRow

type AssetProofI = sqlc.FetchAssetProofRow

type AssetQueryFilters struct {
	tapfreighter.CommitmentConstraints

	// MinAnchorHeight is the minimum block height the asset's anchor tx
	// must have been confirmed at.
	MinAnchorHeight int32
}

type AssetSeedling = sqlc.AssetSeedling

type AssetSeedlingItem = sqlc.InsertAssetSeedlingIntoBatchParams

type AssetSeedlingShell = sqlc.InsertAssetSeedlingParams

type AssetSeedlingTuple = sqlc.FetchSeedlingIDParams

type AssetSprout = sqlc.FetchAssetsForBatchRow

type AssetStatsPerDay = sqlc.QueryAssetStatsPerDaySqliteRow

type AssetStatsPerDayPg = sqlc.QueryAssetStatsPerDayPostgresRow

type AssetStatsPerDayQuery = sqlc.QueryAssetStatsPerDaySqliteParams

type AssetStatsPerDayQueryPg = sqlc.QueryAssetStatsPerDayPostgresParams

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

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

type AssetTransfer = sqlc.AssetTransfer

type AssetTransferRow = sqlc.QueryAssetTransfersRow

type AssetWitness = sqlc.FetchAssetWitnessesRow

type BaseDB struct {
	*sql.DB

	*sqlc.Queries
}

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

type BaseMultiverseStore interface {
	BaseUniverseStore

	UniverseRoots(ctx context.Context,
		params UniverseRootsParams) ([]BaseUniverseRoot, error)
}

type BaseUniverseRoot = sqlc.UniverseRootsRow

type BaseUniverseStore interface {
	UpsertAssetStore

	TreeStore

	FetchGenesisStore

	GroupStore

	// QueryUniverseLeaves is used to query for the set of leaves that
	// reside in a universe tree.
	QueryUniverseLeaves(ctx context.Context,
		arg UniverseLeafQuery) ([]UniverseLeaf, error)

	// DeleteUniverseLeaves is used to delete leaves that reside in a
	// universe tree.
	DeleteUniverseLeaves(ctx context.Context, namespace string) error

	// DeleteUniverseRoot is used to delete the root of a universe tree.
	DeleteUniverseRoot(ctx context.Context, namespace string) error

	// DeleteUniverseEvents is used to delete a universe sync event.
	DeleteUniverseEvents(ctx context.Context, namespace string) error

	// FetchUniverseRoot fetches the root of a universe based on the
	// namespace key, which is a function of the asset ID and the group
	// key.
	FetchUniverseRoot(ctx context.Context,
		namespace string) (UniverseRoot, error)

	// UpsertUniverseLeaf upserts a Universe leaf in the database.
	UpsertUniverseLeaf(ctx context.Context, arg UpsertUniverseLeaf) error

	// UpsertUniverseRoot attempts to insert a universe root, returning the
	// existing primary key of the root if already exists.
	UpsertUniverseRoot(ctx context.Context, arg NewUniverseRoot) (int64,
		error)

	// FetchUniverseKeys fetches the set of keys that are currently stored
	// for a given namespace.
	FetchUniverseKeys(ctx context.Context,
		arg UniverseLeafKeysQuery) ([]UniverseKeys, error)
}

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

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

type BatchChainUpdate = sqlc.BindMintingBatchWithTxParams

type BatchStateUpdate = sqlc.UpdateMintingBatchStateParams

type BatchedAddrBook interface {
	AddrBook

	BatchedTx[AddrBook]
}

type BatchedAssetStore interface {
	ActiveAssetsStore

	BatchedTx[ActiveAssetsStore]
}

type BatchedKeyStore interface {
	KeyStore

	// BatchedTx parametrizes the BatchedTx generic interface w/ KeyStore,
	// which allows us to perform operations to the key store in an atomic
	// transaction. Also add in the TxOptions interface which our defined
	// KeyStoreTxOptions satisfies.
	BatchedTx[KeyStore]
}

type BatchedMultiverse interface {
	BaseMultiverseStore

	BatchedTx[BaseMultiverseStore]
}

type BatchedPendingAssetStore interface {
	PendingAssetStore

	BatchedTx[PendingAssetStore]
}

type BatchedQuerier interface {
	// Querier is the underlying query source, this is in place so we can
	// pass a BatchedQuerier implementation directly into objects that
	// create a batched version of the normal methods they need.
	sqlc.Querier

	// BeginTx creates a new database transaction given the set of
	// transaction options.
	BeginTx(ctx context.Context, options TxOptions) (*sql.Tx, error)

	// Backend returns the type of the database backend used.
	Backend() sqlc.BackendType
}

type BatchedTreeStore interface {
	TreeStore

	BatchedTx[TreeStore]
}

type BatchedTx[Q any] interface {
	// ExecTx will execute the passed txBody, operating upon generic
	// parameter Q (usually a storage interface) in a single transaction.
	// The set of TxOptions are passed in in order to allow the caller to
	// specify if a transaction should be read-only and optionally what
	// type of concurrency control should be used.
	ExecTx(ctx context.Context, txOptions TxOptions,
		txBody func(Q) error) error

	// Backend returns the type of the database backend used.
	Backend() sqlc.BackendType
}

type BatchedUniverseServerStore interface {
	UniverseServerStore

	BatchedTx[UniverseServerStore]
}

type BatchedUniverseStats interface {
	UniverseStatsStore

	BatchedTx[UniverseStatsStore]
}

type BatchedUniverseTree interface {
	BaseUniverseStore

	BatchedTx[BaseUniverseStore]
}

type ChainTx = sqlc.ChainTxn

type ChainTxConf = sqlc.ConfirmChainTxParams

type ChainTxParams = sqlc.UpsertChainTxParams

type ChildQuery = sqlc.FetchChildrenParams

type ConfirmedAsset = sqlc.QueryAssetsRow

type DelNode = sqlc.DeleteNodeParams

type DelUniverseServer = sqlc.DeleteUniverseServerParams

type DeleteFedProofSyncLogParams = sqlc.DeleteFederationProofSyncLogParams

type ErrSerializationError struct {
	DbError error
}

type ErrSqlUniqueConstraintViolation struct {
	DbError error
}

type FedGlobalSyncConfig = sqlc.FederationGlobalSyncConfig

type FedUniSyncConfigs = sqlc.FederationUniSyncConfig

type FederationProofSyncLogStore interface {
	BaseUniverseStore

	// UpsertFederationProofSyncLog upserts a proof sync log entry for a
	// given proof leaf and server.
	UpsertFederationProofSyncLog(ctx context.Context,
		arg UpsertFedProofSyncLogParams) (int64, error)

	// QueryFederationProofSyncLog returns the set of proof sync logs for a
	// given proof leaf.
	QueryFederationProofSyncLog(ctx context.Context,
		arg QueryFedProofSyncLogParams) ([]ProofSyncLogEntry, error)

	// DeleteFederationProofSyncLog deletes proof sync log entries.
	DeleteFederationProofSyncLog(ctx context.Context,
		arg DeleteFedProofSyncLogParams) error
}

type FederationSyncConfigStore interface {
	// UpsertFederationGlobalSyncConfig sets the global federation sync
	// config for a given proof type.
	UpsertFederationGlobalSyncConfig(ctx context.Context,
		arg UpsertFedGlobalSyncConfigParams) error

	// QueryFederationGlobalSyncConfigs returns all global federation sync
	// configurations.
	QueryFederationGlobalSyncConfigs(
		ctx context.Context) ([]FedGlobalSyncConfig, error)

	// UpsertFederationUniSyncConfig inserts or updates a universe specific
	// federation sync config.
	UpsertFederationUniSyncConfig(ctx context.Context,
		arg UpsertFedUniSyncConfigParams) error

	// QueryFederationUniSyncConfigs returns the set of universe specific
	// federation sync configs.
	QueryFederationUniSyncConfigs(ctx context.Context) ([]FedUniSyncConfigs,
		error)
}

type FetchAssetProof = sqlc.FetchAssetProofParams

type FetchGenesisStore interface {
	// FetchGenesisByID returns a single genesis asset by its primary key
	// ID.
	FetchGenesisByID(ctx context.Context, assetID int64) (Genesis, error)
}

type Genesis = sqlc.FetchGenesisByIDRow

type GenesisAsset = sqlc.UpsertGenesisAssetParams

type GenesisPointAnchor = sqlc.AnchorGenesisPointParams

type GenesisTxUpdate = sqlc.UpdateBatchGenesisTxParams

type GroupStore interface {
	FetchGenesisStore

	// FetchGroupByGenesis fetches information on the asset group created
	// with the asset genesis referenced by a specific genesis ID.
	FetchGroupByGenesis(ctx context.Context,
		genesisID int64) (sqlc.FetchGroupByGenesisRow, error)

	// FetchGroupByGroupKey fetches information on the asset group with
	// a matching group key.
	FetchGroupByGroupKey(ctx context.Context,
		groupKey []byte) (sqlc.FetchGroupByGroupKeyRow, error)
}

type InternalKey = sqlc.UpsertInternalKeyParams

type KeyStore interface {
	// GetRootKey fetches the root key associated with the passed ID.
	GetRootKey(ctx context.Context, id []byte) (MacaroonRootKey, error)

	// InsertRootKey inserts a new (id, rootKey) tuple into the database.
	InsertRootKey(ctx context.Context, arg MacaroonID) error
}

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

type LogProofTransAttemptParams = sqlc.LogProofTransferAttemptParams

type MacaroonID = sqlc.InsertRootKeyParams

type MacaroonRootKey = sqlc.Macaroon

type ManagedUTXO struct {
	// OutPoint is the outpoint of the UTXO.
	OutPoint wire.OutPoint

	// OutputValue is the satoshi output value of the UTXO.
	OutputValue btcutil.Amount

	// InternalKey is the internal key that's used to anchor the commitment
	// in the outpoint.
	InternalKey keychain.KeyDescriptor

	// TaprootAssetRoot is the Taproot Asset commitment root hash committed
	// to by this outpoint.
	TaprootAssetRoot []byte

	// MerkleRoot is the Taproot merkle root hash committed to by this
	// outpoint. If there is no Tapscript sibling, this is equal to
	// TaprootAssetRoot.
	MerkleRoot []byte

	// TapscriptSibling is the serialized tapscript sibling preimage of
	// this asset. This will usually be blank.
	TapscriptSibling []byte
}

type ManagedUTXORow = sqlc.FetchManagedUTXOsRow

type MintingBatchA = sqlc.AllMintingBatchesRow

type MintingBatchF = sqlc.FetchMintingBatchRow

type MintingBatchI = sqlc.FetchMintingBatchesByInverseStateRow

type MintingBatchInit = sqlc.NewMintingBatchParams

type MintingBatchTuple = sqlc.UpdateMintingBatchStateParams

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

type NewAddr = sqlc.InsertAddrParams

type NewAssetMeta = sqlc.UpsertAssetMetaParams

type NewAssetTransfer = sqlc.InsertAssetTransferParams

type NewBranch = sqlc.InsertBranchParams

type NewCompactedLeaf = sqlc.InsertCompactedLeafParams

type NewLeaf = sqlc.InsertLeafParams

type NewPassiveAsset = sqlc.InsertPassiveAssetParams

type NewProofEvent = sqlc.InsertNewProofEventParams

type NewScriptKey = sqlc.UpsertScriptKeyParams

type NewSyncEvent = sqlc.InsertNewSyncEventParams

type NewTransferInput = sqlc.InsertAssetTransferInputParams

type NewTransferOutput = sqlc.InsertAssetTransferOutputParams

type NewUniverseRoot = sqlc.UpsertUniverseRootParams

type NewUniverseServer = sqlc.InsertUniverseServerParams

type PassiveAsset = sqlc.QueryPassiveAssetsRow

type PendingAssetStore interface {
	// UpsertAssetStore houses the methods related to inserting/updating
	// assets.
	UpsertAssetStore

	// GroupStore houses the methods related to querying asset groups.
	GroupStore

	// NewMintingBatch creates a new minting batch.
	NewMintingBatch(ctx context.Context, arg MintingBatchInit) error

	// UpdateMintingBatchState updates the state of an existing minting
	// batch.
	UpdateMintingBatchState(ctx context.Context,
		arg BatchStateUpdate) error

	// InsertAssetSeedling inserts a new asset seedling (base description)
	// into the database.
	InsertAssetSeedling(ctx context.Context, arg AssetSeedlingShell) error

	// InsertAssetSeedlingIntoBatch inserts a new asset seedling into a
	// batch based on the batch key its included in.
	InsertAssetSeedlingIntoBatch(ctx context.Context,
		arg AssetSeedlingItem) error

	// AllMintingBatches is used to fetch all minting batches.
	AllMintingBatches(ctx context.Context) ([]MintingBatchA, error)

	// FetchMintingBatchesByInverseState is used to fetch minting batches
	// that don't have a particular state.
	FetchMintingBatchesByInverseState(ctx context.Context,
		batchState int16) ([]MintingBatchI, error)

	// FetchMintingBatch is used to fetch a single minting batch specified
	// by the batch key.
	FetchMintingBatch(ctx context.Context,
		rawKey []byte) (MintingBatchF, error)

	// FetchSeedlingsForBatch is used to fetch all the seedlings by the key
	// of the batch they're included in.
	FetchSeedlingsForBatch(ctx context.Context,
		rawKey []byte) ([]sqlc.FetchSeedlingsForBatchRow, error)

	// FetchSeedlingID is used to look up the ID of a specific seedling
	// in a batch.
	FetchSeedlingID(ctx context.Context, arg AssetSeedlingTuple) (int64,
		error)

	// FetchSeedlingByID is used to look up a specific seedling.
	FetchSeedlingByID(ctx context.Context,
		seedlingID int64) (AssetSeedling, error)

	// BindMintingBatchWithTx adds the minting transaction to an existing
	// batch.
	BindMintingBatchWithTx(ctx context.Context, arg BatchChainUpdate) error

	// UpdateBatchGenesisTx updates the batch tx attached to an existing
	// batch.
	UpdateBatchGenesisTx(ctx context.Context, arg GenesisTxUpdate) error

	// UpsertManagedUTXO inserts a new or updates an existing managed UTXO
	// to disk and returns the primary key.
	UpsertManagedUTXO(ctx context.Context, arg RawManagedUTXO) (int64,
		error)

	// AnchorPendingAssets associated an asset on disk with the transaction
	// that once confirmed will mint the asset.
	AnchorPendingAssets(ctx context.Context, arg AssetAnchor) error

	// UpsertChainTx inserts a new or updates an existing chain tx into the
	// DB.
	UpsertChainTx(ctx context.Context, arg ChainTxParams) (int64, error)

	// ConfirmChainTx confirms an existing chain tx.
	ConfirmChainTx(ctx context.Context, arg ChainTxConf) error

	// FetchAssetsForBatch fetches all the assets created by a particular
	// batch.
	FetchAssetsForBatch(ctx context.Context, rawKey []byte) ([]AssetSprout,
		error)

	// UpsertAssetProof inserts a new or updates an existing asset proof on
	// disk.
	//
	// TODO(roasbeef): move somewhere else??
	UpsertAssetProof(ctx context.Context,
		arg sqlc.UpsertAssetProofParams) error

	// FetchAssetMetaForAsset fetches the asset meta for a given asset.
	FetchAssetMetaForAsset(ctx context.Context,
		assetID []byte) (sqlc.FetchAssetMetaForAssetRow, error)
}

type PostgresConfig struct {
	SkipMigrations     bool          `long:"skipmigrations" description:"Skip applying migrations on startup."`
	Host               string        `long:"host" description:"Database server hostname."`
	Port               int           `long:"port" description:"Database server port."`
	User               string        `long:"user" description:"Database user."`
	Password           string        `long:"password" description:"Database user's password."`
	DBName             string        `long:"dbname" description:"Database name to use."`
	MaxOpenConnections int           `long:"maxconnections" description:"Max open connections to keep alive to the database server."`
	MaxIdleConnections int           `long:"maxidleconnections" description:"Max number of idle connections to keep in the connection pool."`
	ConnMaxLifetime    time.Duration `long:"connmaxlifetime" description:"Max amount of time a connection can be reused for before it is closed."`
	ConnMaxIdleTime    time.Duration `long:"connmaxidletime" description:"Max amount of time a connection can be idle for before it is closed."`
	RequireSSL         bool          `long:"requiressl" description:"Whether to require using SSL (mode: require) when connecting to the server."`
}

type PostgresStore struct {
	*BaseDB
	// contains filtered or unexported fields
}

type PrevInput = sqlc.UpsertAssetWitnessParams

type ProofKey [32]byte

type ProofSyncLogEntry = sqlc.QueryFederationProofSyncLogRow

type ProofUpdate = sqlc.UpsertAssetProofParams

type ProofUpdateByID = sqlc.UpsertAssetProofByIDParams

type QueryAssetFilters = sqlc.QueryAssetsParams

type QueryCreator[Q any] func(*sql.Tx) Q

type QueryFedProofSyncLogParams = sqlc.QueryFederationProofSyncLogParams

type QueryProofTransAttemptsParams = sqlc.QueryProofTransferAttemptsParams

type QueryUniServersParams = sqlc.QueryUniverseServersParams

type RawAssetBalance = sqlc.QueryAssetBalancesByAssetRow

type RawAssetGroupBalance = sqlc.QueryAssetBalancesByGroupRow

type RawGroupedAsset = sqlc.FetchGroupedAssetsRow

type RawManagedUTXO = sqlc.UpsertManagedUTXOParams

type ReAnchorParams = sqlc.ReAnchorPassiveAssetsParams

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

type ScriptKey = sqlc.FetchScriptKeyByTweakedKeyRow

type SetAssetSpentParams = sqlc.SetAssetSpentParams

type SqliteConfig struct {
	// SkipMigrations if true, then all the tables will be created on start
	// up if they don't already exist.
	SkipMigrations bool `long:"skipmigrations" description:"Skip applying migrations on startup."`

	// DatabaseFileName is the full file path where the database file can be
	// found.
	DatabaseFileName string `long:"dbfile" description:"The full path to the database."`
}

type SqliteStore struct {
	*BaseDB
	// contains filtered or unexported fields
}

type StoredNode = sqlc.FetchChildrenRow

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

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

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

type TransactionExecutor[Query any] struct {
	BatchedQuerier
	// contains filtered or unexported fields
}

type TransferInput = sqlc.AssetTransferInput

type TransferInputRow = sqlc.FetchTransferInputsRow

type TransferOutput = sqlc.AssetTransferOutput

type TransferOutputRow = sqlc.FetchTransferOutputsRow

type TransferQuery = sqlc.QueryAssetTransfersParams

type TreeStore interface {
	// InsertBranch inserts a new branch to the store.
	InsertBranch(ctx context.Context, newNode NewBranch) error

	// InsertLeaf inserts a new leaf to the store.
	InsertLeaf(ctx context.Context, newNode NewLeaf) error

	// InsertCompactedLeaf inserts a new compacted leaf to the store.
	InsertCompactedLeaf(ctx context.Context, newNode NewCompactedLeaf) error

	// FetchChildren fetches the children (at most two currently) of the
	// passed branch hash key.
	FetchChildren(ctx context.Context, c ChildQuery) ([]StoredNode, error)

	// DeleteNode deletes a node (can be either branch, leaf of compacted
	// leaf) from the store.
	DeleteNode(ctx context.Context, n DelNode) (int64, error)

	// DeleteAllNodes deletes all nodes from the store.
	DeleteAllNodes(ctx context.Context, namespace string) (int64, error)

	// DeleteRoot deletes a root node from the store.
	DeleteRoot(ctx context.Context, namespace string) (int64, error)

	// FetchRootNode fetches the root node for the specified namespace.
	FetchRootNode(ctx context.Context,
		namespace string) (sqlc.MssmtNode, error)

	// UpsertRootNode allows us to update the root node in place for a
	// given namespace.
	UpsertRootNode(ctx context.Context, arg UpdateRoot) error
}

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

type Tx interface {
	// Commit commits the database transaction, an error should be returned
	// if the commit isn't possible.
	Commit() error

	// Rollback rolls back an incomplete database transaction.
	// Transactions that were able to be committed can still call this as a
	// noop.
	Rollback() error
}

type TxExecutorOption func(*txExecutorOptions)

type TxOptions interface {
	// ReadOnly returns true if the transaction should be read only.
	ReadOnly() bool
}

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

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

type UniverseKeys = sqlc.FetchUniverseKeysRow

type UniverseLeaf = sqlc.QueryUniverseLeavesRow

type UniverseLeafKeysQuery = sqlc.FetchUniverseKeysParams

type UniverseLeafQuery = sqlc.QueryUniverseLeavesParams

type UniverseRoot = sqlc.FetchUniverseRootRow

type UniverseRootsParams = sqlc.UniverseRootsParams

type UniverseServerStore interface {
	FederationSyncConfigStore
	FederationProofSyncLogStore

	// InsertUniverseServer inserts a new universe server in to the DB.
	InsertUniverseServer(ctx context.Context, arg NewUniverseServer) error

	// DeleteUniverseServer removes a universe server from the store.
	DeleteUniverseServer(ctx context.Context, r DelUniverseServer) error

	// LogServerSync marks that a server was just synced in the DB.
	LogServerSync(ctx context.Context, arg sqlc.LogServerSyncParams) error

	// QueryUniverseServers returns a set of universe servers.
	QueryUniverseServers(ctx context.Context,
		arg sqlc.QueryUniverseServersParams) ([]sqlc.UniverseServer,
		error)
}

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

type UniverseStatsOption func(*statsOpts)

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

type UniverseStatsQuery = sqlc.QueryUniverseAssetStatsParams

type UniverseStatsResp = sqlc.QueryUniverseAssetStatsRow

type UniverseStatsStore interface {
	// InsertNewProofEvent inserts a new proof event into the database.
	InsertNewProofEvent(ctx context.Context, arg NewProofEvent) error

	// InsertNewSyncEvent inserts a new sync event into the database.
	InsertNewSyncEvent(ctx context.Context, arg NewSyncEvent) error

	// QueryUniverseStats returns the aggregated stats for the entire
	QueryUniverseStats(ctx context.Context) (AggregateStats, error)

	// QueryUniverseAssetStats returns the stats for a given asset within a
	// universe/
	QueryUniverseAssetStats(ctx context.Context,
		arg UniverseStatsQuery) ([]UniverseStatsResp, error)

	// QueryAssetStatsPerDaySqlite returns the stats for a given asset
	// grouped by day in a SQLite specific format.
	QueryAssetStatsPerDaySqlite(ctx context.Context,
		q AssetStatsPerDayQuery) ([]AssetStatsPerDay, error)

	// QueryAssetStatsPerDayPostgres returns the stats for a given asset
	// grouped by day in a Postgres specific format.
	QueryAssetStatsPerDayPostgres(ctx context.Context,
		q AssetStatsPerDayQueryPg) ([]AssetStatsPerDayPg, error)
}

type UpdateRoot = sqlc.UpsertRootNodeParams

type UpdateUTXOLease = sqlc.UpdateUTXOLeaseParams

type UpsertAddrEvent = sqlc.UpsertAddrEventParams

type UpsertAssetStore interface {
	// UpsertGenesisPoint inserts a new or updates an existing genesis point
	// on disk, and returns the primary key.
	UpsertGenesisPoint(ctx context.Context, prevOut []byte) (int64, error)

	// AnchorGenesisPoint associates a genesis point with the transaction
	// that mints the associated assets on disk.
	AnchorGenesisPoint(ctx context.Context, arg GenesisPointAnchor) error

	// UpsertChainTx inserts a new or updates an existing chain tx into the
	// DB.
	UpsertChainTx(ctx context.Context, arg ChainTxParams) (int64, error)

	// UpsertGenesisAsset inserts a new or updates an existing genesis asset
	// (the base asset info) in the DB, and returns the primary key.
	//
	// TODO(roasbeef): hybrid version of the main tx interface that an
	// accept two diff storage interfaces?
	//
	//  * or use a sort of mix-in type?
	UpsertGenesisAsset(ctx context.Context, arg GenesisAsset) (int64, error)

	// FetchGenesisID is used to fetch the database ID of asset genesis
	// information already in the DB.
	FetchGenesisID(ctx context.Context,
		arg sqlc.FetchGenesisIDParams) (int64, error)

	// FetchScriptKeyIDByTweakedKey determines the database ID of a script
	// key by querying it by the tweaked key.
	FetchScriptKeyIDByTweakedKey(ctx context.Context,
		tweakedScriptKey []byte) (int64, error)

	// UpsertInternalKey inserts a new or updates an existing internal key
	// into the database.
	UpsertInternalKey(ctx context.Context, arg InternalKey) (int64, error)

	// UpsertScriptKey inserts a new script key on disk into the DB.
	UpsertScriptKey(context.Context, NewScriptKey) (int64, error)

	// UpsertAssetGroupWitness inserts a new asset group witness into the DB.
	UpsertAssetGroupWitness(ctx context.Context,
		arg AssetGroupWitness) (int64, error)

	// UpsertAssetGroupKey inserts a new or updates an existing group key
	// on disk, and returns the primary key.
	UpsertAssetGroupKey(ctx context.Context, arg AssetGroupKey) (int64,
		error)

	// QueryAssets fetches a filtered set of fully confirmed assets.
	QueryAssets(context.Context, QueryAssetFilters) ([]ConfirmedAsset,
		error)

	// InsertNewAsset inserts a new asset on disk.
	InsertNewAsset(ctx context.Context,
		arg sqlc.InsertNewAssetParams) (int64, error)

	// UpsertAssetMeta inserts a new asset meta into the DB.
	UpsertAssetMeta(ctx context.Context, arg NewAssetMeta) (int64, error)

	// SetAssetSpent marks an asset as being spent in the database. The
	// updated asset's database ID is returned.
	SetAssetSpent(ctx context.Context, arg SetAssetSpentParams) (int64,
		error)
}

type UpsertFedGlobalSyncConfigParams = sqlc.UpsertFederationGlobalSyncConfigParams

type UpsertFedProofSyncLogParams = sqlc.UpsertFederationProofSyncLogParams

type UpsertFedUniSyncConfigParams = sqlc.UpsertFederationUniSyncConfigParams

type UpsertUniverseLeaf = sqlc.UpsertUniverseLeafParams

type UtxoQuery = sqlc.FetchManagedUTXOParams