From bdeff567ff4a2b92315077f4d76e0abfb599ef94 Mon Sep 17 00:00:00 2001 From: Samuel Laferriere Date: Fri, 9 Aug 2024 11:18:17 -0700 Subject: [PATCH] Add gas bumping txmgr (#284) * Updated chainio and signer READMEs + some code comments added gas oracle refactored txmgr module added geometric txmgr make fmt log -> logger in simple txmgr add TODO + rename constructor update geometric txmgr to use sync api gasoracle refactor chore: switch to pointer to gasoracle in geometric txmgr Also added some comments example: add example test for geometric txmgr fix(geometric_example_test): start anvil container refactor(geometric txmgr): delete gasoracle and add its methods to geometric txmgr directly make fmt fix(lint): remove no longer used variable hundred wip moving geometric to its own subdir simplify privatekey_wallet delete old moved files add geometric txmgr metrics interface + noop metrics docs: add default values in geometric txmgr params comment test(geometric txmgr): add first simple test for geometric txmgr test(geometric txmgr): add some basic tx sending tests feat(ecdsa): add KeyAndAddressFromHexKey helper function feat(geometric txmgr): add integration test scaffold with 1 simple tx sending test fix(geometric txmgr): remove unneeded mutex test(geometric txmgr): add parallel mining logic to fakeEthBackend.SendTransaction to test parallel sending of txs feat(geometrix txmgr): refactor queryTicketDuration to be a param instead of a fixed const refactor(txmgr test harness): refactor into a mining goroutine fix(geometric txmgr test): use mutex to get rid of race condition refactor(geometric txmgr params): made all params public fields feat(geometric txmgr test): added congestedBlocks field to test network congestion where txs need to get bumped also made tests run fast by setting txmgr's GetTxReceiptTickerDuration to 100ms instead of the default 3s fix(geometric txmgr): bug in ensureAnyTxBroadcasted ethereum.NotFound errors were not handled properly, causing txs to never get bumped feat(geometric txmgr test): added congested network test * fix(geometric txmgr test): race condition to set congested blocks * fix compilation errors from prev rebase * make fmt * fix(geometric txmgr): make ethBackend interface private * doc(geometri txmgr): add default GetTxReceiptTickerDuration param as comment * chore(geometric txmgr): remove no longer used GasPricePercentageMultiplier param * doc(geometrix txmgr): comment ProcessTransaction -> processTransaction Co-authored-by: Madhur Shrimal * chore(geometric txmgr): move code around to make it cleaner * chore(geometric txmgr): use utils.WrapError everywhere instead of fmt.Errorf * doc(geometric txmgr): added comment saying that we (probably) can delete while iterating over go map * make fmt * make fmt * refactor(geometric txmgr): change gas/gastip params to use floats instead of percentages * docs(geometric txmgr): add comments for the ensureAnyTxBroadcasted/Confirmed fcts * fix(typo): READMD -> README * make fmt * refactor(geometric txmgr): simplify code by only calling ensureAnyTxBroadcasted for fireblock wallet * fix(geometric txmgr): revert to old (correct) code for catching timeout errors * make fmt * refactor(ecdsa/utils): use strings.TrimPrefix to trim 0x prefix * delete(metrics.go): duplicate file, no longer needed * refactor(geometric txmgr): rename fct with clearer name for self-documentation * doc(geometric txmgr): fix comment that was not true * doc(geometric txmgr): correct comment * test(geometric txmgr): add test for sending tx with incorrect nonce * test(geometric txmgr): added parallel test that sends nonces in reverse order * doc(geometric txmgr): add comment explaining that processTransaction is goroutine safe * chore(geometric txmgr): uncomment code that was commented while debugging --------- Co-authored-by: Madhur Shrimal --- chainio/README.md | 34 +- chainio/clients/wallet/README.md | 3 + chainio/clients/wallet/privatekey_wallet.go | 43 +- .../clients/wallet/privatekey_wallet_test.go | 70 ++ chainio/clients/wallet/wallet.go | 3 +- chainio/txmgr/README.md | 16 +- chainio/txmgr/geometric/geometric.go | 623 ++++++++++++++++++ .../txmgr/geometric/geometric_example_test.go | 85 +++ chainio/txmgr/geometric/geometric_test.go | 417 ++++++++++++ chainio/txmgr/geometric/metrics.go | 142 ++++ chainio/txmgr/simple-tx-manager-flow.png | Bin 82096 -> 198489 bytes chainio/txmgr/simple.go | 201 ++++++ chainio/txmgr/txmgr.go | 206 +----- crypto/ecdsa/utils.go | 13 + signer/README.md | 4 + signerv2/README.md | 3 + testutils/anvil.go | 4 +- testutils/crypto.go | 22 + testutils/logging.go | 18 + 19 files changed, 1660 insertions(+), 247 deletions(-) create mode 100644 chainio/clients/wallet/README.md create mode 100644 chainio/clients/wallet/privatekey_wallet_test.go create mode 100644 chainio/txmgr/geometric/geometric.go create mode 100644 chainio/txmgr/geometric/geometric_example_test.go create mode 100644 chainio/txmgr/geometric/geometric_test.go create mode 100644 chainio/txmgr/geometric/metrics.go create mode 100644 chainio/txmgr/simple.go create mode 100644 signerv2/README.md create mode 100644 testutils/crypto.go create mode 100644 testutils/logging.go diff --git a/chainio/README.md b/chainio/README.md index 1371e7ab..2051311b 100644 --- a/chainio/README.md +++ b/chainio/README.md @@ -1,20 +1,30 @@ ## ChainIO -This module is used to facilitate reading/writing/subscribing to [eigenlayer core](./clients/elcontracts/) contracts and [avs registry](./clients/avsregistry/) contracts. -To make it easier to understand the different structs in this package, and their hierarchical relationship, we describe each of them below: -- geth's ethClient -- eigensdk [ethClient](./clients/eth/client.go) - - wraps geth's ethClient and adds convenience methods -- [eigenlayerContractBindings](../contracts/bindings/) +### Interacting with a json-rpc node + +We have a basic [ethClient](./clients/eth/client.go) which simply wraps geth's ethClient and adds some convenience methods. The Client interface is also implemented by [instrumentedClient](./clients/eth/instrumented_client.go) which adds metrics to the ethClient to conform to the node spec's [rpc metrics](https://docs.eigenlayer.xyz/eigenlayer/avs-guides/spec/metrics/metrics-prom-spec#rpc-metrics) requirements. + + +### Building Transactions + +In order to facilitate reading/writing/subscribing to [eigenlayer core](./clients/elcontracts/) contracts and [avs registry](./clients/avsregistry/) contracts, we use geth's abigen created bindings for low-level interactions, as well as our own high-level clients with higher utility functions: +- [Eigenlayer Contract Bindings](./clients/elcontracts/bindings.go) - generated by abigen - low level bindings to eigenlayer core contracts, which wrap our ethClient -- [elContractsClient](./clients/eth/client.go) - - wraps eigenlayerContractBindings and hides a little bit of the underlying complexity, which is not needed in 99% of cases. - - abigen also doesn't create an interface for the bindings it generates, whereas elContractsClient has a well defined interface which we use to generate mocks to help with testing. - [ELChainReader](./clients/elcontracts/reader.go) / [ELChainWriter](./clients/elcontracts/writer.go) / [ELChainSubscriber](./clients/avsregistry/subscriber.go) - - wraps elContractsClient and adds convenience methods - - hides even more complexity than elContractsClient + - wraps bindings and adds convenience methods - These structs should be the only ones used by AVS developers, apart from interacting with an ethClient directly to make direct json rpc calls such as waiting for a transaction receipt. -A similar hierarchy applies for the avs registry contracts. +There's a similar setup for the [avs registry](./clients/avsregistry/) contracts. + +### Signing, Sending, and Managing Transactions + +After building transactions, we need to sign them, send them to the network, and manage the nonce and gas price to ensure they are mined. This functionality is provided by: +- [txmgr](./txmgr/README.md) + - uses a wallet to sign and submit transactions, but then manages them by resubmitting with higher gas prices until they are mined. +- [wallet](./clients/wallet) + - uses a signerv2 to sign transactions, sends them to the network and can query for their receipts + - wallet abstraction is needed because "wallets", such as fireblocks, both sign and send transactions to the network (they don't simply return signed bytes so that we can send them ourselves) +- [signerv2](../signerv2/README.md) + - signs transactions \ No newline at end of file diff --git a/chainio/clients/wallet/README.md b/chainio/clients/wallet/README.md new file mode 100644 index 00000000..86d53d82 --- /dev/null +++ b/chainio/clients/wallet/README.md @@ -0,0 +1,3 @@ +# Wallet + +TODO \ No newline at end of file diff --git a/chainio/clients/wallet/privatekey_wallet.go b/chainio/clients/wallet/privatekey_wallet.go index acec1ee8..f98a4225 100644 --- a/chainio/clients/wallet/privatekey_wallet.go +++ b/chainio/clients/wallet/privatekey_wallet.go @@ -3,31 +3,30 @@ package wallet import ( "context" "fmt" - "math/big" "github.com/Layr-Labs/eigensdk-go/logging" "github.com/Layr-Labs/eigensdk-go/signerv2" "github.com/Layr-Labs/eigensdk-go/utils" - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" ) -var _ Wallet = (*privateKeyWallet)(nil) +type EthBackend interface { + SendTransaction(ctx context.Context, tx *types.Transaction) error + TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) +} type privateKeyWallet struct { - ethClient ethClient + ethClient EthBackend address common.Address signerFn signerv2.SignerFn logger logging.Logger - - // cache - contracts map[common.Address]*bind.BoundContract } +var _ Wallet = (*privateKeyWallet)(nil) + func NewPrivateKeyWallet( - ethClient ethClient, + ethClient EthBackend, signer signerv2.SignerFn, signerAddress common.Address, logger logging.Logger, @@ -37,7 +36,6 @@ func NewPrivateKeyWallet( address: signerAddress, signerFn: signer, logger: logger, - contracts: make(map[common.Address]*bind.BoundContract, 0), }, nil } @@ -50,32 +48,17 @@ func (t *privateKeyWallet) SendTransaction(ctx context.Context, tx *types.Transa } t.logger.Debug("Sending transaction") - opts := &bind.TransactOpts{ - From: t.address, - Nonce: new(big.Int).SetUint64(tx.Nonce()), - Signer: signer, - Value: tx.Value(), - GasFeeCap: tx.GasFeeCap(), - GasTipCap: tx.GasTipCap(), - GasLimit: tx.Gas(), - Context: ctx, - } - - contract := t.contracts[*tx.To()] - // if the contract has not been cached - if contract == nil { - // create a dummy bound contract tied to the `to` address of the transaction - contract = bind.NewBoundContract(*tx.To(), abi.ABI{}, t.ethClient, t.ethClient, t.ethClient) - // cache the contract for later use - t.contracts[*tx.To()] = contract + signedTx, err := signer(t.address, tx) + if err != nil { + return "", utils.WrapError(fmt.Errorf("sign: tx %v failed.", tx.Hash().String()), err) } - sendingTx, err := contract.RawTransact(opts, tx.Data()) + err = t.ethClient.SendTransaction(ctx, signedTx) if err != nil { return "", utils.WrapError(fmt.Errorf("send: tx %v failed.", tx.Hash().String()), err) } - return sendingTx.Hash().Hex(), nil + return signedTx.Hash().Hex(), nil } func (t *privateKeyWallet) GetTransactionReceipt(ctx context.Context, txID TxID) (*types.Receipt, error) { diff --git a/chainio/clients/wallet/privatekey_wallet_test.go b/chainio/clients/wallet/privatekey_wallet_test.go new file mode 100644 index 00000000..1cb1a9ce --- /dev/null +++ b/chainio/clients/wallet/privatekey_wallet_test.go @@ -0,0 +1,70 @@ +package wallet + +import ( + "context" + "math/big" + "testing" + "time" + + "github.com/Layr-Labs/eigensdk-go/signerv2" + "github.com/Layr-Labs/eigensdk-go/testutils" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethclient" + "github.com/stretchr/testify/require" +) + +var ( + chainId = big.NewInt(31337) +) + +func TestPrivateKeyWallet(t *testing.T) { + logger := testutils.NewTestLogger() + + t.Run("SendTransaction + GetTransactionReceipt", func(t *testing.T) { + anvilC, err := testutils.StartAnvilContainer("") + require.NoError(t, err) + ctxWithTimeout, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + anvilHttpEndpoint, err := anvilC.Endpoint(ctxWithTimeout, "http") + require.NoError(t, err) + ethClient, err := ethclient.Dial(anvilHttpEndpoint) + require.NoError(t, err) + + ecdsaPrivKeyHex := "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" + ecdsaPrivKey, err := crypto.HexToECDSA(ecdsaPrivKeyHex) + require.NoError(t, err) + signerV2, signerAddr, err := signerv2.SignerFromConfig(signerv2.Config{PrivateKey: ecdsaPrivKey}, chainId) + if err != nil { + panic(err) + } + + skWallet, err := NewPrivateKeyWallet(ethClient, signerV2, signerAddr, logger) + require.NoError(t, err) + + tx := types.NewTx(&types.DynamicFeeTx{ + ChainID: chainId, + Nonce: 0, + GasTipCap: big.NewInt(1), + GasFeeCap: big.NewInt(1_000_000_000), + Gas: 21000, + To: &signerAddr, + Value: big.NewInt(1), + }) + ctxWithTimeout, cancel = context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + txId, err := skWallet.SendTransaction(ctxWithTimeout, tx) + require.NoError(t, err) + + // need to give some time for anvil to process the tx and mine the block + // TODO: shall we expose a public WaitForTxReceipt function in the wallet interface, or somewhere else? + time.Sleep(3 * time.Second) + + ctxWithTimeout, cancel = context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + receipt, err := skWallet.GetTransactionReceipt(ctxWithTimeout, txId) + require.NoError(t, err) + // make sure the txHash in the mined tx receipt matches the once we sent + require.Equal(t, txId, receipt.TxHash.String()) + }) +} diff --git a/chainio/clients/wallet/wallet.go b/chainio/clients/wallet/wallet.go index 95f9b526..ff300704 100644 --- a/chainio/clients/wallet/wallet.go +++ b/chainio/clients/wallet/wallet.go @@ -9,7 +9,8 @@ import ( type TxID = string -// Wallet is an interface for signing and sending transactions to the network +// Wallet is an interface for signing and sending transactions to the txpool. +// For a higher-level interface that includes nonce management and gas bumping, use the TxManager interface. // This interface is used to abstract the process of sending transactions to the Ethereum network // For example, for an MPC signer, the transaction would be broadcasted via an external API endpoint // and the status is tracked via another external endpoint instead of being broadcasted diff --git a/chainio/txmgr/README.md b/chainio/txmgr/README.md index 186d3647..b8cc6715 100644 --- a/chainio/txmgr/README.md +++ b/chainio/txmgr/README.md @@ -1,12 +1,20 @@ ## Transaction Manager + Transaction Manager is responsible for * Building transactions -* Estimating fees and adding buffer +* Estimating fees and adding gas limit buffer * Signing transactions * Sending transactions to the network +* Doing transaction nonce and gas price management to ensure transactions are mined -### Simple Transaction Manager -Here's the flow of the simple transaction manager which is used to send smart contract -transactions to the network. +Here's the flow of the simple transaction manager which is used to send smart contract transactions to the network. ![Simple Transaction Manager](./simple-tx-manager-flow.png) + +### Simple Transaction Manager + +The simple txmgr simply sends transactions to the network, waits for them to be mined, and returns the receipt. It doesn't do any managing. + +### Geometric Transaction Manager + +The geometric txmgr is a more advanced version of the simple txmgr. It sends transactions to the network, waits for them to be mined, and if they are not mined within a certain time, it bumps the gas price geometrically and resubmits the transaction. This process is repeated until the transaction is mined. \ No newline at end of file diff --git a/chainio/txmgr/geometric/geometric.go b/chainio/txmgr/geometric/geometric.go new file mode 100644 index 00000000..896c80b0 --- /dev/null +++ b/chainio/txmgr/geometric/geometric.go @@ -0,0 +1,623 @@ +package geometric + +import ( + "context" + "errors" + "fmt" + "math/big" + "net/url" + "time" + + "github.com/Layr-Labs/eigensdk-go/chainio/clients/wallet" + "github.com/Layr-Labs/eigensdk-go/chainio/txmgr" + "github.com/Layr-Labs/eigensdk-go/logging" + "github.com/Layr-Labs/eigensdk-go/utils" + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +type transaction struct { + *types.Transaction + TxID wallet.TxID + requestedAt time.Time +} + +type txnRequest struct { + tx *types.Transaction + + requestedAt time.Time + // txAttempts are the transactions that have been attempted to be mined for this request. + // If a transaction hasn't been confirmed within the timeout and a replacement transaction is sent, + // the original transaction hash will be kept in this slice + txAttempts []*transaction +} + +type ethBackend interface { + BlockNumber(ctx context.Context) (uint64, error) + SuggestGasTipCap(ctx context.Context) (*big.Int, error) + EstimateGas(ctx context.Context, msg ethereum.CallMsg) (uint64, error) + HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) +} + +type GeometricTxManager struct { + ethClient ethBackend + wallet wallet.Wallet + logger logging.Logger + metrics Metrics + + // consts + params GeometricTxnManagerParams +} + +var _ txmgr.TxManager = (*GeometricTxManager)(nil) + +// GeometricTxnManagerParams contains the parameters for the GeometricTxManager. +// If a parameter is not set (aka its zero value is present in the struct), the default value will be used. +type GeometricTxnManagerParams struct { + // number of blocks to wait for a transaction to be confirmed + // default: 0 + ConfirmationBlocks int + // time to wait for a transaction to be broadcasted to the network + // could be direct via eth_sendRawTransaction or indirect via a wallet service such as fireblocks + // default: 2 minutes + TxnBroadcastTimeout time.Duration + // time to wait for a transaction to be confirmed (mined + confirmationBlocks blocks) + // default: 5 * 12 seconds + TxnConfirmationTimeout time.Duration + // max number of times to retry sending a transaction before failing + // this applies to every transaction attempt when a nonce is bumped + // default: 3 + MaxSendTransactionRetry int + // time to wait between checking for each transaction receipt + // while monitoring transactions to get mined + // default: 3 seconds + GetTxReceiptTickerDuration time.Duration + // default gas tip cap to use when eth_maxPriorityFeePerGas is not available + // default: 5 gwei + FallbackGasTipCap uint64 + // multiplier for gas limit to add a buffer and increase chance of tx getting included. Should be >= 1.0 + // default: 1.2 + GasMultiplier float64 + // multiplier for gas tip. Should be >= 1.0 + // default: 1.25 + GasTipMultiplier float64 +} + +var defaultParams = GeometricTxnManagerParams{ + ConfirmationBlocks: 0, // tx mined is considered confirmed + TxnBroadcastTimeout: 2 * time.Minute, // fireblocks has had issues so we give it a long time + TxnConfirmationTimeout: 5 * 12 * time.Second, // 5 blocks + MaxSendTransactionRetry: 3, // arbitrary + GetTxReceiptTickerDuration: 3 * time.Second, + FallbackGasTipCap: uint64(5_000_000_000), // 5 gwei + GasMultiplier: float64(1.20), // add an extra 20% gas buffer to the gas limit + GasTipMultiplier: float64(1.25), // add an extra 25% to the gas tip +} + +func fillUnsetParamsWithDefaultValues(params *GeometricTxnManagerParams) { + if params.ConfirmationBlocks == 0 { + params.ConfirmationBlocks = defaultParams.ConfirmationBlocks + } + if params.TxnBroadcastTimeout == 0 { + params.TxnBroadcastTimeout = defaultParams.TxnBroadcastTimeout + } + if params.TxnConfirmationTimeout == 0 { + params.TxnConfirmationTimeout = defaultParams.TxnConfirmationTimeout + } + if params.MaxSendTransactionRetry == 0 { + params.MaxSendTransactionRetry = defaultParams.MaxSendTransactionRetry + } + if params.GetTxReceiptTickerDuration == 0 { + params.GetTxReceiptTickerDuration = defaultParams.GetTxReceiptTickerDuration + } + if params.FallbackGasTipCap == 0 { + params.FallbackGasTipCap = defaultParams.FallbackGasTipCap + } + if params.GasMultiplier == 0 { + params.GasMultiplier = defaultParams.GasMultiplier + } + if params.GasTipMultiplier == 0 { + params.GasTipMultiplier = defaultParams.GasTipMultiplier + } +} + +func NewGeometricTxnManager( + ethClient ethBackend, + wallet wallet.Wallet, + logger logging.Logger, + metrics Metrics, + params GeometricTxnManagerParams, +) *GeometricTxManager { + fillUnsetParamsWithDefaultValues(¶ms) + return &GeometricTxManager{ + ethClient: ethClient, + wallet: wallet, + logger: logger.With("component", "GeometricTxManager"), + metrics: metrics, + params: params, + } +} + +// GetNoSendTxOpts This generates a noSend TransactOpts so that we can use +// this to generate the transaction without actually sending it +func (m *GeometricTxManager) GetNoSendTxOpts() (*bind.TransactOpts, error) { + ctxWithTimeout, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + from, err := m.wallet.SenderAddress(ctxWithTimeout) + if err != nil { + return nil, utils.WrapError("failed to get sender address", err) + } + return &bind.TransactOpts{ + From: from, + NoSend: true, + Signer: txmgr.NoopSigner, + }, nil +} + +func newTxnRequest(tx *types.Transaction) *txnRequest { + return &txnRequest{ + tx: tx, + requestedAt: time.Now(), + txAttempts: make([]*transaction, 0), + } +} + +// Send is used to sign and send a transaction to an evm chain. +// It does gas estimation and gas price bumping to ensure the transaction gets mined, +// but it does not do nonce management, so the tx argument must have the correct nonce already set. +// +// Send is blocking and safe to call concurrently, so sending multiple txs in parallel is safe. +func (t *GeometricTxManager) Send(ctx context.Context, tx *types.Transaction) (*types.Receipt, error) { + return t.processTransaction(ctx, newTxnRequest(tx)) +} + +// processTransaction sends the transaction and runs a monitoring loop to bump the gasPrice until the tx get included. +// processTransaction can be called concurrently, so sending multiple txs in parallel is safe. +// However, the nonces have to be set correctly by the caller. One could send txs with nonces 3,2,1,0 in this order. +// But sending nonces 2,1 and forgetting 0 would cause the manager to get stuck waiting for nonce 0 to be mined. +// Thus a wallet which manages nonces should be used to ensure the correct nonce is set. +func (t *GeometricTxManager) processTransaction(ctx context.Context, req *txnRequest) (*types.Receipt, error) { + t.logger.Debug("new transaction", + "nonce", req.tx.Nonce(), "gasFeeCap", req.tx.GasFeeCap(), "gasTipCap", req.tx.GasTipCap(), + ) + t.metrics.IncrementProcessingTxCount() + defer t.metrics.DecrementProcessingTxCount() + + from, err := t.wallet.SenderAddress(ctx) + if err != nil { + return nil, utils.WrapError("failed to get sender address", err) + } + + var txn *types.Transaction + var txID wallet.TxID + retryFromFailure := 0 + for retryFromFailure < t.params.MaxSendTransactionRetry { + gasTipCap, err := t.estimateGasTipCap(ctx) + if err != nil { + return nil, utils.WrapError("failed to estimate gas tip cap", err) + } + txn, err = t.updateGasTipCap(ctx, req.tx, gasTipCap, from) + if err != nil { + return nil, utils.WrapError("failed to update gas price", err) + } + txID, err = t.wallet.SendTransaction(ctx, txn) + // the fireblocks and privatekey wallets use go's net.Http client which returns a url.Error on timeouts + // see https://pkg.go.dev/net/http#Client.Do + // context.DeadlineExceeded error is returned by any other (non-network) context timeouting. + // so we need this ugly code to catch both forms of timeout. + // Perhaps we could in the fireblocks client convert the url.Error into context.DeadlineExceeded errors? + var urlErr *url.Error + didTimeout := false + if errors.As(err, &urlErr) { + didTimeout = urlErr.Timeout() + } + if didTimeout || errors.Is(err, context.DeadlineExceeded) { + t.logger.Warn( + "failed to send txn due to timeout", + "hash", + txn.Hash().Hex(), + "numRetries", + retryFromFailure, + "maxRetry", + t.params.MaxSendTransactionRetry, + "err", + err, + ) + // TODO: why do we only retry on client or server timeouts? what about other errors? + retryFromFailure++ + continue + } else if err != nil { + return nil, utils.WrapError(fmt.Errorf("failed to send txn %s", txn.Hash().Hex()), err) + } else { + t.logger.Debug("successfully sent txn", "txID", txID, "txHash", txn.Hash().Hex()) + break + } + } + // if all attempts to send the tx failed, return an error + if txn == nil || txID == "" { + return nil, utils.WrapError(fmt.Errorf("failed to send txn %s", req.tx.Hash().Hex()), err) + } + + req.tx = txn + req.txAttempts = append(req.txAttempts, &transaction{ + TxID: txID, + Transaction: txn, + requestedAt: time.Now(), + }) + + receipt, err := t.monitorTransaction(ctx, req) + if err == nil { + if receipt.GasUsed > 0 { + t.metrics.ObserveGasUsedWei(receipt.GasUsed) + } + t.metrics.ObserveConfirmationLatencyMs(time.Since(req.requestedAt).Milliseconds()) + } + return receipt, err +} + +// ensureAnyFireblocksTransactionBroadcasted waits until at least one of the bumped transactions are broadcasted to the +// network. +// this is only needed for the Fireblocks wallet, where some processing is done in their backend before broadcasting to +// the ethereum network. +func (t *GeometricTxManager) ensureAnyFireblocksTransactionBroadcasted(ctx context.Context, txs []*transaction) error { + queryTicker := time.NewTicker(t.params.GetTxReceiptTickerDuration) + defer queryTicker.Stop() + + for { + for _, tx := range txs { + _, err := t.wallet.GetTransactionReceipt(ctx, tx.TxID) + if err == nil || errors.Is(err, wallet.ErrReceiptNotYetAvailable) { + t.metrics.ObserveBroadcastLatencyMs(time.Since(tx.requestedAt).Milliseconds()) + return nil + } + } + + // Wait for the next round. + select { + case <-ctx.Done(): + return ctx.Err() + case <-queryTicker.C: + } + } +} + +// ensureAnyTransactionConfirmed waits until at least one of the transactions is confirmed (mined + confirmationBlocks +// blocks). It returns the receipt of the first transaction that is confirmed (only one tx can ever be mined given they +// all have the same nonce). +func (t *GeometricTxManager) ensureAnyTransactionConfirmed( + ctx context.Context, + txs []*transaction, +) (*types.Receipt, error) { + queryTicker := time.NewTicker(t.params.GetTxReceiptTickerDuration) + defer queryTicker.Stop() + var receipt *types.Receipt + var err error + // transactions that need to be queried. Some transactions will be removed from this map depending on their status. + txnsToQuery := make(map[wallet.TxID]*types.Transaction, len(txs)) + for _, tx := range txs { + txnsToQuery[tx.TxID] = tx.Transaction + } + + for { + for txID, tx := range txnsToQuery { + receipt, err = t.wallet.GetTransactionReceipt(ctx, txID) + if err == nil { + chainTip, err := t.ethClient.BlockNumber(ctx) + if err == nil { + if receipt.BlockNumber.Uint64()+uint64(t.params.ConfirmationBlocks) > chainTip { + t.logger.Debug( + "transaction has been mined but don't have enough confirmations at current chain tip", + "txnBlockNumber", + receipt.BlockNumber.Uint64(), + "numConfirmations", + t.params.ConfirmationBlocks, + "chainTip", + chainTip, + ) + break + } else { + return receipt, nil + } + } else { + t.logger.Debug("failed to get chain tip while waiting for transaction to mine", "err", err) + } + } + + // TODO(samlaf): how to maintain these better? How do we know which errors to use and where they are + // returned from? + if errors.Is(err, ethereum.NotFound) || errors.Is(err, wallet.ErrReceiptNotYetAvailable) { + t.logger.Debug("Transaction not yet mined", "nonce", tx.Nonce(), "txID", txID, "txHash", + tx.Hash().Hex(), "err", err) + } else if errors.Is(err, wallet.ErrTransactionFailed) { + t.logger.Debug("Transaction failed", "txID", txID, "txHash", tx.Hash().Hex(), "err", err) + // Remove the transaction from the list of transactions to query. + // go seemingly allows deleting from a map while iterating over it: + // https://groups.google.com/g/golang-nuts/c/rEmaoxi11_A + // although the official spec and faq don't seem to mention this anywhere... + delete(txnsToQuery, txID) + } else if errors.Is(err, wallet.ErrNotYetBroadcasted) { + t.logger.Error("Transaction has not been broadcasted to network but attempted to retrieve receipt", "err", err) + } else { + t.logger.Debug("Transaction receipt retrieval failed", "err", err) + } + } + + if len(txnsToQuery) == 0 { + return nil, fmt.Errorf("all transactions failed") + } + + // Wait for the next round. + select { + case <-ctx.Done(): + return receipt, ctx.Err() + case <-queryTicker.C: + } + } +} + +// monitorTransaction waits until the transaction is confirmed (or failed) and resends it with a higher gas price if it +// is not mined without a timeout. +// It returns the receipt once the transaction has been confirmed. +// It returns an error if the transaction fails to be sent for reasons other than timeouts. +func (t *GeometricTxManager) monitorTransaction(ctx context.Context, req *txnRequest) (*types.Receipt, error) { + numSpeedUps := 0 + retryFromFailure := 0 + + var receipt *types.Receipt + var err error + + rpcCallAttempt := func() error { + t.logger.Debug("monitoring transaction", "txHash", req.tx.Hash().Hex(), "nonce", req.tx.Nonce()) + + ctxWithTimeout, cancelBroadcastTimeout := context.WithTimeout(ctx, t.params.TxnBroadcastTimeout) + defer cancelBroadcastTimeout() + + if fireblocksWallet, ok := t.wallet.(interface { + CancelTransactionBroadcast(ctx context.Context, txID wallet.TxID) (bool, error) + }); ok { + // Fireblocks wallet is used, there may be delays in broadcasting the transaction due to + // latency from cosigning and MPC operations. We thus make sure that at least one of the + // bumped transactions are broadcasted to the network before querying for its receipt. + err = t.ensureAnyFireblocksTransactionBroadcasted(ctxWithTimeout, req.txAttempts) + if err != nil && errors.Is(err, context.DeadlineExceeded) { + t.logger.Warn( + "transaction not broadcasted within timeout", + "txHash", + req.tx.Hash().Hex(), + "nonce", + req.tx.Nonce(), + ) + // Consider these transactions failed as they haven't been broadcasted within timeout. + // Cancel these transactions to avoid blocking the next transactions. + for _, tx := range req.txAttempts { + cancelled, err := fireblocksWallet.CancelTransactionBroadcast(ctx, tx.TxID) + if err != nil { + t.logger.Warn("failed to cancel Fireblocks transaction broadcast", "txID", tx.TxID, "err", err) + } else if cancelled { + t.logger.Info("cancelled Fireblocks transaction broadcast because it didn't get broadcasted within timeout", "txID", tx.TxID, "timeout", t.params.TxnBroadcastTimeout.String()) + } + } + return fmt.Errorf("transaction %x (with nonce %d) not broadcasted", req.tx.Hash(), req.tx.Nonce()) + } else if err != nil { + t.logger.Error("unexpected error while waiting for Fireblocks transaction to broadcast", "txHash", req.tx.Hash().Hex(), "err", err) + return err + } + } + + ctxWithTimeout, cancelEvaluationTimeout := context.WithTimeout(ctx, t.params.TxnConfirmationTimeout) + defer cancelEvaluationTimeout() + receipt, err = t.ensureAnyTransactionConfirmed( + ctxWithTimeout, + req.txAttempts, + ) + return err + } + + queryTicker := time.NewTicker(t.params.GetTxReceiptTickerDuration) + defer queryTicker.Stop() + for { + err = rpcCallAttempt() + if err == nil { + t.metrics.ObserveSpeedups(numSpeedUps) + t.metrics.IncrementProcessedTxsTotal("success") + return receipt, nil + } + + if errors.Is(err, context.DeadlineExceeded) { + if receipt != nil { + t.logger.Warn( + "transaction has been mined, but hasn't accumulated the required number of confirmations", + "txHash", + req.tx.Hash().Hex(), + "nonce", + req.tx.Nonce(), + ) + continue + } + t.logger.Warn( + "transaction not mined within timeout, resending with higher gas price", + "txHash", + req.tx.Hash().Hex(), + "nonce", + req.tx.Nonce(), + ) + newTx, err := t.speedUpTxn(ctx, req.tx, numSpeedUps) + if err != nil { + t.logger.Error("failed to speed up transaction", "err", err) + t.metrics.IncrementProcessedTxsTotal("failure") + return nil, err + } + txID, err := t.wallet.SendTransaction(ctx, newTx) + if err != nil { + if retryFromFailure >= t.params.MaxSendTransactionRetry { + t.logger.Warn( + "failed to send txn - retries exhausted", + "txn", + req.tx.Hash().Hex(), + "attempt", + retryFromFailure, + "maxRetry", + t.params.MaxSendTransactionRetry, + "err", + err, + ) + t.metrics.IncrementProcessedTxsTotal("failure") + return nil, err + } else { + t.logger.Warn("failed to send txn - retrying", "txn", req.tx.Hash().Hex(), "attempt", retryFromFailure, "maxRetry", t.params.MaxSendTransactionRetry, "err", err) + } + retryFromFailure++ + continue + } + + t.logger.Debug("successfully sent txn", "txID", txID, "txHash", newTx.Hash().Hex()) + req.tx = newTx + req.txAttempts = append(req.txAttempts, &transaction{ + TxID: txID, + Transaction: newTx, + }) + numSpeedUps++ + } else { + t.logger.Error("transaction failed", "txHash", req.tx.Hash().Hex(), "err", err) + t.metrics.IncrementProcessedTxsTotal("failure") + return nil, err + } + + // Wait for the next round. + select { + case <-ctx.Done(): + return receipt, ctx.Err() + case <-queryTicker.C: + } + } +} + +// speedUpTxn increases the gas price of the existing transaction by specified percentage. +// It makes sure the new gas price is not lower than the current gas price. +func (t *GeometricTxManager) speedUpTxn( + ctx context.Context, + tx *types.Transaction, + numSpeedUps int, +) (*types.Transaction, error) { + // bump the current gasTip, and also reestimate it from the node, and take the highest value + var newGasTipCap *big.Int + { + estimatedGasTipCap, err := t.estimateGasTipCap(ctx) + if err != nil { + return nil, utils.WrapError("failed to estimate gas tip cap", err) + } + bumpedGasTipCap := t.addGasTipCapBuffer(tx.GasTipCap()) + if estimatedGasTipCap.Cmp(bumpedGasTipCap) > 0 { + newGasTipCap = estimatedGasTipCap + } else { + newGasTipCap = bumpedGasTipCap + } + } + + from, err := t.wallet.SenderAddress(ctx) + if err != nil { + return nil, utils.WrapError("failed to get sender address", err) + } + newTx, err := t.updateGasTipCap(ctx, tx, newGasTipCap, from) + if err != nil { + return nil, utils.WrapError("failed to update gas price", err) + } + t.logger.Info( + "increasing gas price", + "numSpeedUps", numSpeedUps, + "prevTxHash", tx.Hash().Hex(), "newTxHash", newTx.Hash().Hex(), + "nonce", tx.Nonce(), + "prevGasTipCap", tx.GasTipCap(), "newGasTipCap", newGasTipCap, + "prevGasFeeCap", tx.GasFeeCap(), "newGasFeeCap", newTx.GasFeeCap(), + ) + return newTx, nil +} + +// UpdateGasParams updates the three gas related parameters of a transaction: +// - gasTipCap: calls the json-rpc method eth_maxPriorityFeePerGas and +// adds a extra buffer based on o.params.GasTipMultiplierPercentage +// - gasFeeCap: calculates the gas fee cap as 2 * baseFee + gasTipCap +// - gasLimit: calls the json-rpc method eth_estimateGas and +// adds a extra buffer based on o.params.GasMultiplierPercentage +func (t *GeometricTxManager) updateGasTipCap( + ctx context.Context, + tx *types.Transaction, + newGasTipCap *big.Int, + from common.Address, +) (*types.Transaction, error) { + gasFeeCap, err := t.estimateGasFeeCap(ctx, newGasTipCap) + if err != nil { + return nil, utils.WrapError("failed to estimate gas fee cap", err) + } + + // we reestimate the gas limit because the state of the chain may have changed, + // which could cause the previous gas limit to be insufficient + gasLimit, err := t.ethClient.EstimateGas(ctx, ethereum.CallMsg{ + From: from, + To: tx.To(), + GasTipCap: newGasTipCap, + GasFeeCap: gasFeeCap, + Value: tx.Value(), + Data: tx.Data(), + }) + if err != nil { + return nil, utils.WrapError("failed to estimate gas", err) + } + // we also add a buffer to the gas limit to account for potential changes in the state of the chain + // between the time of estimation and the time the transaction is mined + bufferedGasLimit := t.addGasBuffer(gasLimit) + + return types.NewTx(&types.DynamicFeeTx{ + ChainID: tx.ChainId(), + Nonce: tx.Nonce(), + GasTipCap: newGasTipCap, + GasFeeCap: gasFeeCap, + Gas: bufferedGasLimit, + To: tx.To(), + Value: tx.Value(), + Data: tx.Data(), + AccessList: tx.AccessList(), + }), nil +} + +func (t *GeometricTxManager) estimateGasTipCap(ctx context.Context) (gasTipCap *big.Int, err error) { + gasTipCap, err = t.ethClient.SuggestGasTipCap(ctx) + if err != nil { + // If the transaction failed because the backend does not support + // eth_maxPriorityFeePerGas, fallback to using the default constant. + // Currently Alchemy is the only backend provider that exposes this + // method, so in the event their API is unreachable we can fallback to a + // degraded mode of operation. This also applies to our test + // environments, as hardhat doesn't support the query either. + // TODO: error could actually come from node not being down or network being slow, etc. + t.logger.Info("eth_maxPriorityFeePerGas is unsupported by current backend, using fallback gasTipCap") + gasTipCap = big.NewInt(0).SetUint64(t.params.FallbackGasTipCap) + } + return t.addGasTipCapBuffer(gasTipCap), nil +} + +// addGasTipCapBuffer adds a buffer to the gas tip cap to account for potential changes in the state of the chain +// The result is returned in a new big.Int to avoid modifying the input gasTipCap. +func (t *GeometricTxManager) addGasTipCapBuffer(gasTipCap *big.Int) *big.Int { + bumpedGasTipCap := new(big.Int).Set(gasTipCap) + return bumpedGasTipCap.Mul(bumpedGasTipCap, big.NewInt(int64(t.params.GasTipMultiplier*100))). + Div(bumpedGasTipCap, big.NewInt(100)) +} + +// estimateGasFeeCap returns the gas fee cap for a transaction, calculated as: +// gasFeeCap = 2 * baseFee + gasTipCap +// Rationale: https://www.blocknative.com/blog/eip-1559-fees +// The result is returned in a new big.Int to avoid modifying gasTipCap. +func (t *GeometricTxManager) estimateGasFeeCap(ctx context.Context, gasTipCap *big.Int) (*big.Int, error) { + header, err := t.ethClient.HeaderByNumber(ctx, nil) + if err != nil { + return nil, utils.WrapError("failed to get latest header", err) + } + return new(big.Int).Add(new(big.Int).Mul(header.BaseFee, big.NewInt(2)), gasTipCap), nil +} + +func (t *GeometricTxManager) addGasBuffer(gasLimit uint64) uint64 { + return uint64(t.params.GasMultiplier * float64(gasLimit)) +} diff --git a/chainio/txmgr/geometric/geometric_example_test.go b/chainio/txmgr/geometric/geometric_example_test.go new file mode 100644 index 00000000..c7f0e75a --- /dev/null +++ b/chainio/txmgr/geometric/geometric_example_test.go @@ -0,0 +1,85 @@ +package geometric + +import ( + "context" + "crypto/ecdsa" + "fmt" + "math/big" + "os" + + "github.com/Layr-Labs/eigensdk-go/chainio/clients/eth" + "github.com/Layr-Labs/eigensdk-go/chainio/clients/wallet" + "github.com/Layr-Labs/eigensdk-go/logging" + "github.com/Layr-Labs/eigensdk-go/signerv2" + "github.com/Layr-Labs/eigensdk-go/testutils" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethclient" + "github.com/prometheus/client_golang/prometheus" +) + +var ( + chainid = big.NewInt(31337) +) + +func ExampleGeometricTxManager() { + anvilC, err := testutils.StartAnvilContainer("") + if err != nil { + panic(err) + } + anvilUrl, err := anvilC.Endpoint(context.TODO(), "http") + if err != nil { + panic(err) + } + + ecdsaPrivateKey, err := crypto.HexToECDSA("ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80") + if err != nil { + panic(err) + } + pk := ecdsaPrivateKey.PublicKey + address := crypto.PubkeyToAddress(pk) + + client, txmgr := createTxMgr(anvilUrl, ecdsaPrivateKey) + + tx := createTx(client, address) + _, err = txmgr.Send(context.TODO(), tx) + if err != nil { + panic(err) + } + + // we just add this to make sure the example runs + fmt.Println("Tx sent") + // Output: Tx sent +} + +func createTx(client eth.HttpBackend, address common.Address) *types.Transaction { + zeroAddr := common.HexToAddress("0x0") + nonce, err := client.PendingNonceAt(context.TODO(), address) + if err != nil { + panic(err) + } + return types.NewTx(&types.DynamicFeeTx{ + To: &zeroAddr, + Nonce: nonce, + }) +} + +func createTxMgr(rpcUrl string, ecdsaPrivateKey *ecdsa.PrivateKey) (eth.HttpBackend, *GeometricTxManager) { + logger := logging.NewTextSLogger(os.Stdout, &logging.SLoggerOptions{}) + client, err := ethclient.Dial(rpcUrl) + if err != nil { + panic(err) + } + signerV2, signerAddr, err := signerv2.SignerFromConfig(signerv2.Config{PrivateKey: ecdsaPrivateKey}, chainid) + if err != nil { + panic(err) + } + wallet, err := wallet.NewPrivateKeyWallet(client, signerV2, signerAddr, logger) + if err != nil { + panic(err) + } + reg := prometheus.NewRegistry() + metrics := NewMetrics(reg, "example", logger) + return client, NewGeometricTxnManager(client, wallet, logger, metrics, GeometricTxnManagerParams{}) +} diff --git a/chainio/txmgr/geometric/geometric_test.go b/chainio/txmgr/geometric/geometric_test.go new file mode 100644 index 00000000..250e79fe --- /dev/null +++ b/chainio/txmgr/geometric/geometric_test.go @@ -0,0 +1,417 @@ +package geometric + +import ( + "context" + "fmt" + "math/big" + "sync" + "testing" + "time" + + "github.com/Layr-Labs/eigensdk-go/chainio/clients/wallet" + "github.com/Layr-Labs/eigensdk-go/crypto/ecdsa" + "github.com/Layr-Labs/eigensdk-go/logging" + "github.com/Layr-Labs/eigensdk-go/signerv2" + "github.com/Layr-Labs/eigensdk-go/testutils" + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/ethclient" + "github.com/stretchr/testify/require" + "golang.org/x/sync/errgroup" +) + +var chainId = big.NewInt(31337) + +type testHarness struct { + fakeEthBackend *fakeEthBackend + txmgr *GeometricTxManager +} + +func (h *testHarness) validateTxReceipt(t *testing.T, txReceipt *types.Receipt) { + ctxWithTimeout, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + receiptFromEthBackend, err := h.fakeEthBackend.TransactionReceipt(ctxWithTimeout, txReceipt.TxHash) + require.NoError(t, err) + require.Equal(t, txReceipt, receiptFromEthBackend) +} + +func newTestHarness(t *testing.T, geometricTxnManagerParams *GeometricTxnManagerParams) *testHarness { + logger := testutils.NewTestLogger() + ethBackend := NewFakeEthBackend() + + ecdsaSk, ecdsaAddr, err := testutils.NewEcdsaSkAndAddress() + require.NoError(t, err) + + signerFn, _, err := signerv2.SignerFromConfig(signerv2.Config{PrivateKey: ecdsaSk}, chainId) + require.NoError(t, err) + + skWallet, err := wallet.NewPrivateKeyWallet(ethBackend, signerFn, ecdsaAddr, logger) + require.NoError(t, err) + + if geometricTxnManagerParams == nil { + geometricTxnManagerParams = &GeometricTxnManagerParams{ + GetTxReceiptTickerDuration: 100 * time.Millisecond, + // set to 100 so that no buffer is added to the gasTipCap + // this way we can test that the txmgr will bump the gasTipCap to a working value + // and also simulate a congested network (with fakeEthBackend.congestedBlocks) where txs won't be mined + GasTipMultiplier: 100, + // set to 1 second (instead of default 2min) so that we can test that the txmgr will bump the gasTipCap to a + // working value + TxnBroadcastTimeout: 1 * time.Second, + } + } + txmgr := NewGeometricTxnManager(ethBackend, skWallet, logger, NewNoopMetrics(), *geometricTxnManagerParams) + + return &testHarness{ + fakeEthBackend: ethBackend, + txmgr: txmgr, + } +} + +func TestGeometricTxManager(t *testing.T) { + t.Run("Send 1 tx", func(t *testing.T) { + h := newTestHarness(t, nil) + + unsignedTx := newUnsignedEthTransferTx(0, nil) + ctxWithTimeout, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + txReceipt, err := h.txmgr.Send(ctxWithTimeout, unsignedTx) + require.NoError(t, err) + + h.validateTxReceipt(t, txReceipt) + }) + + t.Run("Send 1 tx to congested network", func(t *testing.T) { + h := newTestHarness(t, nil) + h.fakeEthBackend.setCongestedBlocks(3) + h.txmgr.params.TxnConfirmationTimeout = 1 * time.Second + + unsignedTx := newUnsignedEthTransferTx(0, nil) + ctxWithTimeout, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + txReceipt, err := h.txmgr.Send(ctxWithTimeout, unsignedTx) + require.NoError(t, err) + + h.validateTxReceipt(t, txReceipt) + }) + + t.Run("gasFeeCap gets overwritten when sending tx", func(t *testing.T) { + h := newTestHarness(t, nil) + + unsignedTx := newUnsignedEthTransferTx(0, big.NewInt(1)) + ctxWithTimeout, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + txReceipt, err := h.txmgr.Send(ctxWithTimeout, unsignedTx) + // ethBackend returns an error if the tx's gasFeeCap is less than the baseFeePerGas + // this test makes sure that even setting a gasFeeCap less than the baseFeePerGas in the tx (1 above) still + // works, + // because the txmgr will overwrite it and set the gasFeeCap to a working value + require.NoError(t, err) + + h.validateTxReceipt(t, txReceipt) + }) + + t.Run("Send n=3 txs in parallel", func(t *testing.T) { + n := 3 + h := newTestHarness(t, nil) + + g := new(errgroup.Group) + + txs := make([]*types.Transaction, n) + txReceipts := make([]*types.Receipt, n) + + for nonce := 0; nonce < n; nonce++ { + tx := newUnsignedEthTransferTx(uint64(nonce), nil) + txs[nonce] = tx + nonce := nonce + g.Go(func() error { + ctxWithTimeout, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + txReceipt, err := h.txmgr.Send(ctxWithTimeout, tx) + if err == nil { + txReceipts[nonce] = txReceipt + } + return err + }) + } + + err := g.Wait() + require.NoError(t, err) + + }) + + t.Run("Send n=3 txs in parallel, with nonces in reverse order", func(t *testing.T) { + n := 3 + h := newTestHarness(t, nil) + + g := new(errgroup.Group) + + txs := make([]*types.Transaction, n) + txReceipts := make([]*types.Receipt, n) + + for nonce := n - 1; nonce >= 0; nonce-- { + tx := newUnsignedEthTransferTx(uint64(nonce), nil) + txs[nonce] = tx + nonce := nonce + g.Go(func() error { + ctxWithTimeout, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + txReceipt, err := h.txmgr.Send(ctxWithTimeout, tx) + if err == nil { + txReceipts[nonce] = txReceipt + } + return err + }) + time.Sleep(1 * time.Second) + } + + err := g.Wait() + require.NoError(t, err) + + }) + + t.Run("Send n=3 txs sequentially", func(t *testing.T) { + n := uint64(3) + h := newTestHarness(t, nil) + + for nonce := uint64(0); nonce < n; nonce++ { + tx := newUnsignedEthTransferTx(nonce, nil) + ctxWithTimeout, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + _, err := h.txmgr.Send(ctxWithTimeout, tx) + require.NoError(t, err) + } + + }) + + t.Run("Send tx with incorrect nonce should result in context.DeadlineExceeded error", func(t *testing.T) { + h := newTestHarness(t, nil) + + tx := newUnsignedEthTransferTx(uint64(100), nil) + ctxWithTimeout, cancel := context.WithTimeout(context.Background(), 2*time.Second) + defer cancel() + _, err := h.txmgr.Send(ctxWithTimeout, tx) + require.Equal(t, context.DeadlineExceeded, err) + + }) + + t.Run("Send 2 txs with same nonce", func(t *testing.T) { + h := newTestHarness(t, nil) + + unsignedTx := newUnsignedEthTransferTx(0, nil) + ctxWithTimeout, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + _, err := h.txmgr.Send(ctxWithTimeout, unsignedTx) + require.NoError(t, err) + + unsignedTx = newUnsignedEthTransferTx(0, nil) + _, err = h.txmgr.Send(ctxWithTimeout, unsignedTx) + require.Error(t, err) + }) +} + +func newUnsignedEthTransferTx(nonce uint64, gasFeeCap *big.Int) *types.Transaction { + if gasFeeCap == nil { + // 1 gwei is anvil's default starting baseFeePerGas on its genesis block + gasFeeCap = big.NewInt(1_000_000_000) + } + return types.NewTx(&types.DynamicFeeTx{ + ChainID: chainId, + Nonce: nonce, + GasTipCap: big.NewInt(1), + GasFeeCap: gasFeeCap, + Gas: 21000, + To: testutils.ZeroAddress(), + Value: big.NewInt(1), + }) +} + +type fakeEthBackend struct { + // congestedBlocks can be set to a positive number to start a congestion period. + // while congestedBlocks > 0, gasTipCap will increase everytime it is read, simulating a congested network + // this way whenever the txmgr reads the gasTipCap to bump a tx and resend it, the gasTipCap will increase + // so as to prevent the tx from being mined + // everytime a block is mined, congestedBlocks will decrease by 1 + congestedBlocks uint64 + gasTipCap *big.Int + baseFeePerGas *big.Int + // mu protects all the below fields which are updated in "mining" goroutines (see Send) + mu sync.Mutex + blockNumber uint64 + // we use a single nonce for now because the txmgr only supports a single sender + nonce uint64 + mempool map[uint64]*types.Transaction // nonce -> tx + minedTxs map[common.Hash]*types.Receipt + logger logging.Logger +} + +func NewFakeEthBackend() *fakeEthBackend { + logger := testutils.NewTestLogger().With("component", "fakeEthBackend") + backend := &fakeEthBackend{ + congestedBlocks: 0, + gasTipCap: big.NewInt(1), // 1 wei, same default as anvil + baseFeePerGas: big.NewInt(1_000_000_000), // 1 gwei, same default as anvil + mu: sync.Mutex{}, + blockNumber: 0, + nonce: 0, + mempool: make(map[uint64]*types.Transaction), + minedTxs: make(map[common.Hash]*types.Receipt), + logger: logger, + } + backend.startMining() + return backend +} + +func (s *fakeEthBackend) WithBaseFeePerGas(baseFeePerGas *big.Int) *fakeEthBackend { + s.baseFeePerGas = baseFeePerGas + return s +} + +func (s *fakeEthBackend) startMining() { + go func() { + for { + s.mu.Lock() + // if there's a tx in the mempool with the current nonce and its gasTipCap is >= baseFeePerGas, mine it + if tx, ok := s.mempool[s.nonce]; ok { + if tx.GasTipCapIntCmp(s.gasTipCap) >= 0 { + delete(s.mempool, s.nonce) + s.minedTxs[tx.Hash()] = &types.Receipt{ + BlockNumber: big.NewInt(int64(s.blockNumber)), + TxHash: tx.Hash(), + } + s.blockNumber++ + s.nonce++ + s.logger.Debug("mined tx", "txHash", tx.Hash(), "nonce", tx.Nonce()) + } else { + s.logger.Info("tx.gasTipCap < fakeEthBackend.gasTipCap, not mining", "txHash", tx.Hash(), "nonce", tx.Nonce(), "tx.gasTipCap", tx.GasTipCap(), "fakeEthBackend.gasTipCap", s.gasTipCap) + } + } + if s.congestedBlocks > 0 { + s.congestedBlocks-- + } + s.mu.Unlock() + // mine a block every 100 ms + time.Sleep(100 * time.Millisecond) + } + }() +} + +func (s *fakeEthBackend) setCongestedBlocks(n uint64) { + s.mu.Lock() + defer s.mu.Unlock() + s.congestedBlocks = n + +} + +func (s *fakeEthBackend) BlockNumber(context.Context) (uint64, error) { + s.mu.Lock() + defer s.mu.Unlock() + return s.blockNumber, nil +} + +func (s *fakeEthBackend) SuggestGasTipCap(ctx context.Context) (*big.Int, error) { + s.mu.Lock() + defer s.mu.Unlock() + gasTipCap := big.NewInt(0).Set(s.gasTipCap) + if s.congestedBlocks > 0 { + s.gasTipCap = s.gasTipCap.Add(s.gasTipCap, big.NewInt(1)) + } + return gasTipCap, nil +} + +func (s *fakeEthBackend) EstimateGas(ctx context.Context, msg ethereum.CallMsg) (uint64, error) { + return 0, nil + +} + +func (s *fakeEthBackend) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) { + return &types.Header{ + BaseFee: big.NewInt(0).Set(s.baseFeePerGas), + }, nil +} + +func (s *fakeEthBackend) SendTransaction(ctx context.Context, tx *types.Transaction) error { + if tx.GasFeeCapIntCmp(s.baseFeePerGas) < 0 { + return fmt.Errorf("tx.gasFeeCap (%d) < baseFeeCap (%d)", tx.GasFeeCap(), s.baseFeePerGas) + } + s.mu.Lock() + defer s.mu.Unlock() + if tx.Nonce() < s.nonce { + return fmt.Errorf("tx.nonce (%d) < current nonce (%d)", tx.Nonce(), s.nonce) + } + s.mempool[tx.Nonce()] = tx + return nil +} + +func (s *fakeEthBackend) TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) { + s.mu.Lock() + defer s.mu.Unlock() + + if receipt, ok := s.minedTxs[txHash]; ok { + return receipt, nil + } + return nil, ethereum.NotFound +} + +// ========================== INTEGRATION TESTS ========================== + +type integrationEthBackend interface { + wallet.EthBackend + ethBackend +} +type integrationTestHarness struct { + ethBackend integrationEthBackend + txmgr *GeometricTxManager +} + +func newIntegrationTestHarness(t *testing.T) *integrationTestHarness { + logger := testutils.NewTestLogger() + anvilC, err := testutils.StartAnvilContainer("") + require.NoError(t, err) + ctxWithTimeout, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + anvilHttpEndpoint, err := anvilC.Endpoint(ctxWithTimeout, "http") + require.NoError(t, err) + anvilHttpClient, err := ethclient.Dial(anvilHttpEndpoint) + require.NoError(t, err) + + ecdsaSk, ecdsaAddr, err := ecdsa.KeyAndAddressFromHexKey( + "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", + ) + require.NoError(t, err) + + signerFn, _, err := signerv2.SignerFromConfig(signerv2.Config{PrivateKey: ecdsaSk}, chainId) + require.NoError(t, err) + + skWallet, err := wallet.NewPrivateKeyWallet(anvilHttpClient, signerFn, ecdsaAddr, logger) + require.NoError(t, err) + + txmgr := NewGeometricTxnManager(anvilHttpClient, skWallet, logger, NewNoopMetrics(), GeometricTxnManagerParams{}) + return &integrationTestHarness{ + ethBackend: anvilHttpClient, + txmgr: txmgr, + } +} + +func (h *integrationTestHarness) validateTxReceipt(t *testing.T, txReceipt *types.Receipt) { + ctxWithTimeout, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + receiptFromEthBackend, err := h.ethBackend.TransactionReceipt(ctxWithTimeout, txReceipt.TxHash) + require.NoError(t, err) + require.Equal(t, txReceipt, receiptFromEthBackend) +} + +func TestGeometricTxManagerIntegration(t *testing.T) { + t.Run("Send 1 tx", func(t *testing.T) { + h := newIntegrationTestHarness(t) + + unsignedTx := newUnsignedEthTransferTx(0, nil) + ctxWithTimeout, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + txReceipt, err := h.txmgr.Send(ctxWithTimeout, unsignedTx) + require.NoError(t, err) + + h.validateTxReceipt(t, txReceipt) + }) +} diff --git a/chainio/txmgr/geometric/metrics.go b/chainio/txmgr/geometric/metrics.go new file mode 100644 index 00000000..00e21264 --- /dev/null +++ b/chainio/txmgr/geometric/metrics.go @@ -0,0 +1,142 @@ +package geometric + +import ( + "github.com/Layr-Labs/eigensdk-go/logging" + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/client_golang/prometheus/promauto" +) + +type Metrics interface { + ObserveBroadcastLatencyMs(latencyMs int64) + ObserveConfirmationLatencyMs(latencyMs int64) + ObserveGasUsedWei(gasUsedWei uint64) + ObserveSpeedups(speedUps int) + IncrementProcessingTxCount() + DecrementProcessingTxCount() + IncrementProcessedTxsTotal(state string) +} + +const namespace = "txmgr" + +type PromMetrics struct { + broadcastLatencyMs prometheus.Summary + confirmationLatencyMs prometheus.Summary + gasUsedGwei prometheus.Summary + speedUps prometheus.Histogram + processingTxCount prometheus.Gauge + processedTxsTotal *prometheus.CounterVec +} + +var _ Metrics = (*PromMetrics)(nil) + +func NewMetrics(reg prometheus.Registerer, subsystem string, logger logging.Logger) *PromMetrics { + + return &PromMetrics{ + // TODO: we only observe latency of txs that were successfully broadcasted or confirmed. + // We should also observe latency of txs that failed to broadcast or confirm. + broadcastLatencyMs: promauto.With(reg).NewSummary( + prometheus.SummaryOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "broadcast_latency_ms", + Help: "transaction confirmation latency summary in milliseconds", + Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.95: 0.01, 0.99: 0.001}, + }, + ), + confirmationLatencyMs: promauto.With(reg).NewSummary( + prometheus.SummaryOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "confirmation_latency_ms", + Help: "total transaction confirmation latency summary in milliseconds", + Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.95: 0.01, 0.99: 0.001}, + }, + ), + gasUsedGwei: promauto.With(reg).NewSummary( + prometheus.SummaryOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "gas_used_total", + Help: "total gas used to submit each transaction onchain", + Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.95: 0.01, 0.99: 0.001}, + }, + ), + speedUps: promauto.With(reg).NewHistogram( + prometheus.HistogramOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "speedups_total", + Help: "number of times a transaction's gas price was increased", + Buckets: prometheus.LinearBuckets(0, 1, 10), + }, + ), + processingTxCount: promauto.With(reg).NewGauge( + prometheus.GaugeOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "processing_tx_count", + Help: "number of transactions currently being processed", + }, + ), + processedTxsTotal: promauto.With(reg).NewCounterVec( + prometheus.CounterOpts{ + Namespace: namespace, + Subsystem: subsystem, + Name: "processed_txs_total", + Help: "number of transactions processed by state (success, error)", + }, + []string{"state"}, + ), + } +} + +func (m *PromMetrics) ObserveBroadcastLatencyMs(latencyMs int64) { + m.broadcastLatencyMs.Observe(float64(latencyMs)) +} + +func (m *PromMetrics) ObserveConfirmationLatencyMs(latencyMs int64) { + m.confirmationLatencyMs.Observe(float64(latencyMs)) +} + +func (m *PromMetrics) ObserveGasUsedWei(gasUsedWei uint64) { + gasUsedGwei := gasUsedWei / 1e9 + m.gasUsedGwei.Observe(float64(gasUsedGwei)) +} + +func (m *PromMetrics) ObserveSpeedups(speedUps int) { + m.speedUps.Observe(float64(speedUps)) +} + +func (m *PromMetrics) IncrementProcessingTxCount() { + m.processingTxCount.Inc() +} + +func (m *PromMetrics) DecrementProcessingTxCount() { + m.processingTxCount.Dec() +} + +func (m *PromMetrics) IncrementProcessedTxsTotal(state string) { + m.processedTxsTotal.WithLabelValues(state).Inc() +} + +type NoopMetrics struct{} + +var _ Metrics = (*NoopMetrics)(nil) + +func NewNoopMetrics() *NoopMetrics { + return &NoopMetrics{} +} + +func (t *NoopMetrics) ObserveBroadcastLatencyMs(latencyMs int64) {} + +func (t *NoopMetrics) ObserveConfirmationLatencyMs(latencyMs int64) {} + +func (t *NoopMetrics) ObserveGasUsedWei(gasUsedWei uint64) {} + +func (t *NoopMetrics) ObserveSpeedups(speedUps int) {} + +func (t *NoopMetrics) IncrementProcessingTxCount() {} + +func (t *NoopMetrics) DecrementProcessingTxCount() {} + +func (t *NoopMetrics) IncrementProcessedTxsTotal(state string) {} diff --git a/chainio/txmgr/simple-tx-manager-flow.png b/chainio/txmgr/simple-tx-manager-flow.png index 4b07b30b57db17decd17f085bacac5904cf8cd07..ac0b5f06243b0ed07e8dbbbbe31e3dec6455354c 100644 GIT binary patch literal 198489 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

8op9BD@Glzzxhr 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�fRrtI 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 P1N`09GSIA4w+{PX1@g2` literal 82096 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