ethfinalizer

type Chain interface {
	ChainID() *big.Int
	IsEIP1559() bool

	LatestNonce(ctx context.Context, address common.Address) (uint64, error)
	PendingNonce(ctx context.Context, address common.Address) (uint64, error)

	Send(ctx context.Context, transaction *types.Transaction) error

	GasPrice(ctx context.Context) (*big.Int, error)
	BaseFee(ctx context.Context) (*big.Int, error)
	PriorityFee(ctx context.Context) (*big.Int, error)

	Subscribe(ctx context.Context) (<-chan Diff, error)
}

type Diff struct {
	Removed, Added map[common.Hash]struct{}
}

type EthkitChainOptions struct {
	ChainID   *big.Int
	IsEIP1559 bool

	// Provider is an ethkit Provider, required.
	Provider *ethrpc.Provider
	// Monitor is a running ethkit Monitor, required.
	Monitor *ethmonitor.Monitor
	// GasGauge is a running ethkit GasGauge, required only for non-EIP-1559 chains.
	GasGauge *ethgas.GasGauge
	// GasGaugeSpeed defaults to GasGaugeSpeedDefault (GasGaugeSpeedFast), unused for EIP-1559 chains.
	GasGaugeSpeed GasGaugeSpeed
	// Logger is used to log chain behaviour, optional.
	Logger *slog.Logger

	PriorityFee *big.Int
}

type Event[T any] struct {
	// Removed is the transaction that was reorged, nil if this was a mining event.
	Removed *Transaction[T]
	// Added is the transaction that was mined, may be nil if a reorg occurred and the reorged transaction was never replaced.
	Added *Transaction[T]
}

type Finalizer[T any] struct {
	FinalizerOptions[T]
	// contains filtered or unexported fields
}

type FinalizerOptions[T any] struct {
	// Wallet is the wallet to be managed by this finalizer, required.
	Wallet *ethwallet.Wallet
	// Chain is the provider for the chain where transactions will be sent, required.
	// See NewEthkitChain for an implementation using ethkit components.
	Chain Chain
	// Mempool stores transactions that this finalizer creates, required.
	// See NewMemoryMempool for a minimal in-memory implementation.
	Mempool Mempool[T]
	// Logger is used to log finalizer behaviour, optional.
	Logger *slog.Logger

	// PollInterval is the period between chain state checks.
	// Required, must be positive.
	PollInterval time.Duration
	// PollTimeout is the time limit for operations while checking chain state.
	// Required, must be positive.
	PollTimeout time.Duration
	// RetryDelay is the minimum time to wait before retrying a transaction.
	// Required, must be positive.
	RetryDelay time.Duration

	// FeeMargin is the percentage added on top of the estimated gas price.
	FeeMargin int
	// PriceBump is the percentage increase when replacing pending transactions.
	// Recommended to be at least 15, 10 is the default chosen by go-ethereum.
	PriceBump int

	// SubscriptionBuffer is the size of the buffer for transaction events.
	SubscriptionBuffer int
}

type GasGaugeSpeed int

type Mempool[T any] interface {
	// Nonce is the next available nonce for the wallet on the chain.
	Nonce(ctx context.Context) (uint64, error)

	// Commit persists the signed transaction with its metadata in the store.
	// The transaction must be persisted with a timestamp of the current time.
	// If the transaction already exists in the mempool, the timestamp must be updated.
	Commit(ctx context.Context, transaction *types.Transaction, metadata T) error

	// Transactions returns the transactions for the specified hashes which are signed by this specific wallet for this specific chain.
	Transactions(ctx context.Context, hashes map[common.Hash]struct{}) (map[common.Hash]*Transaction[T], error)

	// PriciestTransactions returns, by nonce, the most expensive transactions signed by this specific wallet for this specific chain, with a minimum nonce and a latest timestamp.
	PriciestTransactions(ctx context.Context, fromNonce uint64, before time.Time) (map[uint64]*Transaction[T], error)
}

type Transaction[T any] struct {
	*types.Transaction

	Metadata T
}