diff --git a/contracts/Failure.abi b/contracts/Failure.abi index 868236489b..ff81399c4c 100644 --- a/contracts/Failure.abi +++ b/contracts/Failure.abi @@ -1 +1 @@ -[{"inputs":[],"name":"fail","outputs":[],"stateMutability":"payable","type":"function"}] \ No newline at end of file +[{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"fail","outputs":[],"stateMutability":"payable","type":"function"}] \ No newline at end of file diff --git a/contracts/Failure.bin b/contracts/Failure.bin index c6f9cdbb77..0665cc84ab 100644 --- a/contracts/Failure.bin +++ b/contracts/Failure.bin @@ -1 +1 @@ -608060405234801561001057600080fd5b5061010f806100206000396000f3fe608060405260043610601c5760003560e01c8063a9cc4718146021575b600080fd5b60276029565b005b6040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160599060bb565b60405180910390fd5b600082825260208201905092915050565b7f626967206661696c210000000000000000000000000000000000000000000000600082015250565b600060a76009836062565b915060b0826073565b602082019050919050565b6000602082019050818103600083015260d281609c565b905091905056fea264697066735822122068a0ae7d220da2e9f14cc48aec07eb227130c4a4ae2d89dca9c16c132f2c64fe64736f6c634300080d0033 \ No newline at end of file +608060405234801561001057600080fd5b50610285806100206000396000f3fe6080604052600436106100295760003560e01c806342966c681461002e578063a9cc47181461004a575b600080fd5b610048600480360381019061004391906100fa565b610054565b005b610052610084565b005b6000805a90505b825a826100689190610156565b101561007f57816100789061018a565b915061005b565b505050565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100b69061022f565b60405180910390fd5b600080fd5b6000819050919050565b6100d7816100c4565b81146100e257600080fd5b50565b6000813590506100f4816100ce565b92915050565b6000602082840312156101105761010f6100bf565b5b600061011e848285016100e5565b91505092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b6000610161826100c4565b915061016c836100c4565b92508282101561017f5761017e610127565b5b828203905092915050565b6000610195826100c4565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff82036101c7576101c6610127565b5b600182019050919050565b600082825260208201905092915050565b7f626967206661696c210000000000000000000000000000000000000000000000600082015250565b60006102196009836101d2565b9150610224826101e3565b602082019050919050565b600060208201905081810360008301526102488161020c565b905091905056fea264697066735822122026bd9e2efdd6d7fa97c409b84266f2549bcccc67d576b29d337f41226deeae5464736f6c634300080d0033 \ No newline at end of file diff --git a/contracts/Failure.sol b/contracts/Failure.sol index c9e1102c47..cc6ff6018f 100644 --- a/contracts/Failure.sol +++ b/contracts/Failure.sol @@ -5,4 +5,12 @@ contract Failure { function fail() public payable { revert("big fail!"); } + + function burn(uint256 _amount) public payable { + uint256 i = 0; + uint256 initialGas = gasleft(); + while (initialGas - gasleft() < _amount) { + ++i; + } + } } diff --git a/optimism/bindings/failure.go b/optimism/bindings/failure.go index 052645c1b1..efd6083cfe 100644 --- a/optimism/bindings/failure.go +++ b/optimism/bindings/failure.go @@ -30,8 +30,8 @@ var ( // FailureMetaData contains all meta data concerning the Failure contract. var FailureMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"name\":\"fail\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", - Bin: "0x608060405234801561001057600080fd5b5061010f806100206000396000f3fe608060405260043610601c5760003560e01c8063a9cc4718146021575b600080fd5b60276029565b005b6040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160599060bb565b60405180910390fd5b600082825260208201905092915050565b7f626967206661696c210000000000000000000000000000000000000000000000600082015250565b600060a76009836062565b915060b0826073565b602082019050919050565b6000602082019050818103600083015260d281609c565b905091905056fea264697066735822122068a0ae7d220da2e9f14cc48aec07eb227130c4a4ae2d89dca9c16c132f2c64fe64736f6c634300080d0033", + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"ok\",\"type\":\"uint256\"}],\"name\":\"Yep\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"fail\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", + Bin: "0x608060405234801561001057600080fd5b50610285806100206000396000f3fe6080604052600436106100295760003560e01c806342966c681461002e578063a9cc47181461004a575b600080fd5b610048600480360381019061004391906100fa565b610054565b005b610052610084565b005b6000805a90505b825a826100689190610156565b101561007f57816100789061018a565b915061005b565b505050565b6040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100b69061022f565b60405180910390fd5b600080fd5b6000819050919050565b6100d7816100c4565b81146100e257600080fd5b50565b6000813590506100f4816100ce565b92915050565b6000602082840312156101105761010f6100bf565b5b600061011e848285016100e5565b91505092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b6000610161826100c4565b915061016c836100c4565b92508282101561017f5761017e610127565b5b828203905092915050565b6000610195826100c4565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff82036101c7576101c6610127565b5b600182019050919050565b600082825260208201905092915050565b7f626967206661696c210000000000000000000000000000000000000000000000600082015250565b60006102196009836101d2565b9150610224826101e3565b602082019050919050565b600060208201905081810360008301526102488161020c565b905091905056fea26469706673582212206c9066085641202e49d5d997c43f820e5bc6b3985fe0eafd9d8362a2e9522b2664736f6c634300080d0033", } // FailureABI is the input ABI used to generate the binding from. @@ -201,6 +201,27 @@ func (_Failure *FailureTransactorRaw) Transact(opts *bind.TransactOpts, method s return _Failure.Contract.contract.Transact(opts, method, params...) } +// Burn is a paid mutator transaction binding the contract method 0x42966c68. +// +// Solidity: function burn(uint256 _amount) payable returns() +func (_Failure *FailureTransactor) Burn(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error) { + return _Failure.contract.Transact(opts, "burn", _amount) +} + +// Burn is a paid mutator transaction binding the contract method 0x42966c68. +// +// Solidity: function burn(uint256 _amount) payable returns() +func (_Failure *FailureSession) Burn(_amount *big.Int) (*types.Transaction, error) { + return _Failure.Contract.Burn(&_Failure.TransactOpts, _amount) +} + +// Burn is a paid mutator transaction binding the contract method 0x42966c68. +// +// Solidity: function burn(uint256 _amount) payable returns() +func (_Failure *FailureTransactorSession) Burn(_amount *big.Int) (*types.Transaction, error) { + return _Failure.Contract.Burn(&_Failure.TransactOpts, _amount) +} + // Fail is a paid mutator transaction binding the contract method 0xa9cc4718. // // Solidity: function fail() payable returns() @@ -221,3 +242,137 @@ func (_Failure *FailureSession) Fail() (*types.Transaction, error) { func (_Failure *FailureTransactorSession) Fail() (*types.Transaction, error) { return _Failure.Contract.Fail(&_Failure.TransactOpts) } + +// FailureYepIterator is returned from FilterYep and is used to iterate over the raw logs and unpacked data for Yep events raised by the Failure contract. +type FailureYepIterator struct { + Event *FailureYep // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *FailureYepIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(FailureYep) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(FailureYep) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *FailureYepIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *FailureYepIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// FailureYep represents a Yep event raised by the Failure contract. +type FailureYep struct { + Ok *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterYep is a free log retrieval operation binding the contract event 0x14806dfe21dd426fa23d551967947bd5266cc1e2eb26850ed515c8df9c841280. +// +// Solidity: event Yep(uint256 ok) +func (_Failure *FailureFilterer) FilterYep(opts *bind.FilterOpts) (*FailureYepIterator, error) { + + logs, sub, err := _Failure.contract.FilterLogs(opts, "Yep") + if err != nil { + return nil, err + } + return &FailureYepIterator{contract: _Failure.contract, event: "Yep", logs: logs, sub: sub}, nil +} + +// WatchYep is a free log subscription operation binding the contract event 0x14806dfe21dd426fa23d551967947bd5266cc1e2eb26850ed515c8df9c841280. +// +// Solidity: event Yep(uint256 ok) +func (_Failure *FailureFilterer) WatchYep(opts *bind.WatchOpts, sink chan<- *FailureYep) (event.Subscription, error) { + + logs, sub, err := _Failure.contract.WatchLogs(opts, "Yep") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(FailureYep) + if err := _Failure.contract.UnpackLog(event, "Yep", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseYep is a log parse operation binding the contract event 0x14806dfe21dd426fa23d551967947bd5266cc1e2eb26850ed515c8df9c841280. +// +// Solidity: event Yep(uint256 ok) +func (_Failure *FailureFilterer) ParseYep(log types.Log) (*FailureYep, error) { + event := new(FailureYep) + if err := _Failure.contract.UnpackLog(event, "Yep", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/optimism/helper.go b/optimism/helper.go index 4270aad4b2..e2bb48de77 100644 --- a/optimism/helper.go +++ b/optimism/helper.go @@ -4,6 +4,7 @@ import ( "bytes" "context" "errors" + "fmt" "io" "io/ioutil" "time" @@ -72,7 +73,15 @@ func WaitBlock(ctx context.Context, client *ethclient.Client, n uint64) error { return nil } -func WaitReceipt(ctx context.Context, client *ethclient.Client, hash common.Hash) (*types.Receipt, error) { +func WaitReceiptOK(ctx context.Context, client *ethclient.Client, hash common.Hash) (*types.Receipt, error) { + return WaitReceipt(ctx, client, hash, types.ReceiptStatusSuccessful) +} + +func WaitReceiptFail(ctx context.Context, client *ethclient.Client, hash common.Hash) (*types.Receipt, error) { + return WaitReceipt(ctx, client, hash, types.ReceiptStatusFailed) +} + +func WaitReceipt(ctx context.Context, client *ethclient.Client, hash common.Hash, status uint64) (*types.Receipt, error) { ticker := time.NewTicker(100 * time.Millisecond) defer ticker.Stop() for { @@ -88,8 +97,8 @@ func WaitReceipt(ctx context.Context, client *ethclient.Client, hash common.Hash if err != nil { return nil, err } - if receipt.Status == types.ReceiptStatusFailed { - return receipt, ErrTransactionFailed + if receipt.Status != status { + return receipt, fmt.Errorf("expected status %d, but got %d", status, receipt.Status) } return receipt, nil } diff --git a/simulators/optimism/l1ops/deposit_tests.go b/simulators/optimism/l1ops/deposit_tests.go index 8d01f7a1c1..43c456948c 100644 --- a/simulators/optimism/l1ops/deposit_tests.go +++ b/simulators/optimism/l1ops/deposit_tests.go @@ -103,7 +103,7 @@ func erc20RoundtripTest(t *hivesim.T, env *optimism.TestEnv) { // Deploy the ERC20 on L1 l1Opts := l1Vault.KeyedTransactor(depositor) l1ERC20Addr, tx, l1ERC20, err := hivebindings.DeploySimpleERC20(l1Opts, l1, big.NewInt(1_000_000), "Test L1", 18, "L1") - _, err = optimism.WaitReceipt(env.TimeoutCtx(30*time.Second), l1, tx.Hash()) + _, err = optimism.WaitReceiptOK(env.TimeoutCtx(30*time.Second), l1, tx.Hash()) require.NoError(t, err) // Deposit some ETH onto L2 @@ -114,7 +114,7 @@ func erc20RoundtripTest(t *hivesim.T, env *optimism.TestEnv) { factory := env.Devnet.Bindings.BindingsL2.OptimismMintableERC20Factory tx, err = factory.CreateOptimismMintableERC20(l2Opts, l1ERC20Addr, "Test L1", "L2") require.NoError(t, err) - receipt, err := optimism.WaitReceipt(env.TimeoutCtx(30*time.Second), l2, tx.Hash()) + receipt, err := optimism.WaitReceiptOK(env.TimeoutCtx(30*time.Second), l2, tx.Hash()) var creationEvent *bindings.OptimismMintableERC20FactoryOptimismMintableERC20Created for _, log := range receipt.Logs { if log.Topics[0] != optimismMintableERC20CreatedEvent { @@ -139,7 +139,7 @@ func erc20RoundtripTest(t *hivesim.T, env *optimism.TestEnv) { // approve tx, err = l1ERC20.Approve(l1Opts, predeploys.DevL1StandardBridgeAddr, abi.MaxUint256) require.NoError(t, err) - _, err = optimism.WaitReceipt(env.TimeoutCtx(30*time.Second), l1, tx.Hash()) + _, err = optimism.WaitReceiptOK(env.TimeoutCtx(30*time.Second), l1, tx.Hash()) require.NoError(t, err) // Remember starting L2 block to find the relay @@ -149,7 +149,7 @@ func erc20RoundtripTest(t *hivesim.T, env *optimism.TestEnv) { // Do the deposit tx, err = l1SB.DepositERC20(l1Opts, l1ERC20Addr, l2ERC20Addr, big.NewInt(1000), 200_000, nil) require.NoError(t, err) - receipt, err = optimism.WaitReceipt(env.TimeoutCtx(30*time.Second), l1, tx.Hash()) + receipt, err = optimism.WaitReceiptOK(env.TimeoutCtx(30*time.Second), l1, tx.Hash()) require.NoError(t, err) var l1SentMessage *bindings.L1CrossDomainMessengerSentMessage for _, log := range receipt.Logs { @@ -218,7 +218,7 @@ func erc20RoundtripTest(t *hivesim.T, env *optimism.TestEnv) { // Perform the withdrawal tx, err = l2SB.Withdraw(l2Opts, l2ERC20Addr, big.NewInt(500), 0, nil) require.NoError(t, err) - receipt, err = optimism.WaitReceipt(env.TimeoutCtx(30*time.Second), l2, tx.Hash()) + receipt, err = optimism.WaitReceiptOK(env.TimeoutCtx(30*time.Second), l2, tx.Hash()) require.NoError(t, err) // Await finalization period @@ -259,7 +259,7 @@ func erc20RoundtripTest(t *hivesim.T, env *optimism.TestEnv) { wParams.WithdrawalProof, ) require.NoError(t, err) - _, err = optimism.WaitReceipt(env.TimeoutCtx(time.Minute), l1, finTx.Hash()) + _, err = optimism.WaitReceiptOK(env.TimeoutCtx(time.Minute), l1, finTx.Hash()) require.NoError(t, err) // Verify L1/L2 balances @@ -287,10 +287,9 @@ func failingDepositWithMintTest(t *hivesim.T, env *optimism.TestEnv) { doDeposit(t, env, depositor, big.NewInt(0.5*params.Ether), false, nil) // Deploy the failure contract on L2 - _, deployTx, failureContract, err := hivebindings.DeployFailure(l2Opts, l2) require.NoError(t, err) - _, err = optimism.WaitReceipt(env.TimeoutCtx(30*time.Second), l2, deployTx.Hash()) + _, err = optimism.WaitReceiptOK(env.TimeoutCtx(30*time.Second), l2, deployTx.Hash()) require.NoError(t, err) // Create the revert() call @@ -299,38 +298,44 @@ func failingDepositWithMintTest(t *hivesim.T, env *optimism.TestEnv) { revertTx, err := failureContract.Fail(l2Opts) require.NoError(t, err) + // Create transaction that burns more gas on L2 than allotted + // in the deposit transaction. + l2Opts.GasLimit = 3_000_000 + burnTx, err := failureContract.Burn(l2Opts, big.NewInt(2_000_000)) + require.NoError(t, err) + // Create garbage data randData := make([]byte, 32) _, err = rand.Read(randData) require.NoError(t, err) - testData := [][]byte{ - randData, - revertTx.Data(), + testData := []*types.Transaction{ + revertTx, + burnTx, } mintAmount := big.NewInt(0.5 * params.Ether) opts := l1Vault.KeyedTransactor(depositor) opts.Value = mintAmount opts.GasLimit = 3_000_000 - for _, data := range testData { + for _, testTx := range testData { startBal, err := l2.BalanceAt(env.Ctx(), depositor, nil) require.NoError(t, err) tx, err := depositContract.DepositTransaction( opts, - depositor, + *testTx.To(), mintAmount, 1_000_000, false, - data, + testTx.Data(), ) require.NoError(t, err) - receipt, err := optimism.WaitReceipt(env.TimeoutCtx(time.Minute), l1, tx.Hash()) + receipt, err := optimism.WaitReceiptOK(env.TimeoutCtx(time.Minute), l1, tx.Hash()) require.NoError(t, err) reconstructedDep, err := derive.UnmarshalDepositLogEvent(receipt.Logs[0]) require.NoError(t, err, "could not reconstruct L2 deposit") tx = types.NewTx(reconstructedDep) - _, err = optimism.WaitReceipt(env.TimeoutCtx(45*time.Second), l2, tx.Hash()) + _, err = optimism.WaitReceiptFail(env.TimeoutCtx(45*time.Second), l2, tx.Hash()) require.NoError(t, err) endBal, err := l2.BalanceAt(env.Ctx(), depositor, nil) @@ -353,23 +358,23 @@ func doDeposit(t *hivesim.T, env *optimism.TestEnv, depositor common.Address, mi opts.GasLimit = 3_000_000 tx, err := depositContract.DepositTransaction(opts, depositor, common.Big0, 1_000_000, isCreation, data) require.NoError(t, err) - receipt, err := optimism.WaitReceipt(env.TimeoutCtx(time.Minute), l1, tx.Hash()) + receipt, err := optimism.WaitReceiptOK(env.TimeoutCtx(time.Minute), l1, tx.Hash()) require.NoError(t, err) reconstructedDep, err := derive.UnmarshalDepositLogEvent(receipt.Logs[0]) require.NoError(t, err, "could not reconstruct L2 deposit") tx = types.NewTx(reconstructedDep) - _, err = optimism.WaitReceipt(env.TimeoutCtx(45*time.Second), l2, tx.Hash()) + _, err = optimism.WaitReceiptOK(env.TimeoutCtx(45*time.Second), l2, tx.Hash()) require.NoError(t, err) } func awaitDeposit(t *hivesim.T, env *optimism.TestEnv, tx *types.Transaction, l1, l2 *ethclient.Client) *types.Receipt { - receipt, err := optimism.WaitReceipt(env.TimeoutCtx(time.Minute), l1, tx.Hash()) + receipt, err := optimism.WaitReceiptOK(env.TimeoutCtx(time.Minute), l1, tx.Hash()) require.NoError(t, err) reconstructedDep, err := derive.UnmarshalDepositLogEvent(receipt.Logs[0]) require.NoError(t, err, "could not reconstruct L2 deposit") tx = types.NewTx(reconstructedDep) - receipt, err = optimism.WaitReceipt(env.TimeoutCtx(45*time.Second), l2, tx.Hash()) + receipt, err = optimism.WaitReceiptOK(env.TimeoutCtx(45*time.Second), l2, tx.Hash()) require.NoError(t, err) return receipt } diff --git a/simulators/optimism/l1ops/withdrawal_tests.go b/simulators/optimism/l1ops/withdrawal_tests.go index 78c1966300..7910bb729e 100644 --- a/simulators/optimism/l1ops/withdrawal_tests.go +++ b/simulators/optimism/l1ops/withdrawal_tests.go @@ -33,7 +33,7 @@ func simpleWithdrawalTest(t *hivesim.T, env *optimism.TestEnv) { l2Opts.Value = withdrawAmount initTx, err := l2Wd.InitiateWithdrawal(l2Opts, depositor, big.NewInt(21000), nil) require.NoError(t, err) - initReceipt, err := optimism.WaitReceipt(env.TimeoutCtx(time.Minute), l2, initTx.Hash()) + initReceipt, err := optimism.WaitReceiptOK(env.TimeoutCtx(time.Minute), l2, initTx.Hash()) require.NoError(t, err) require.Equal(t, initReceipt.Status, types.ReceiptStatusSuccessful) @@ -78,7 +78,7 @@ func simpleWithdrawalTest(t *hivesim.T, env *optimism.TestEnv) { ) require.NoError(t, err) - finReceipt, err := optimism.WaitReceipt(env.TimeoutCtx(time.Minute), l1, finTx.Hash()) + finReceipt, err := optimism.WaitReceiptOK(env.TimeoutCtx(time.Minute), l1, finTx.Hash()) require.NoError(t, err) require.Equal(t, types.ReceiptStatusSuccessful, finReceipt.Status) diff --git a/simulators/optimism/p2p/main.go b/simulators/optimism/p2p/main.go index c0dce5db23..21643fc5eb 100644 --- a/simulators/optimism/p2p/main.go +++ b/simulators/optimism/p2p/main.go @@ -3,14 +3,14 @@ package main import ( "context" "fmt" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/params" "math/big" "sync" "time" "github.com/ethereum-optimism/optimism/op-node/eth" "github.com/ethereum-optimism/optimism/op-node/rollup/driver" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/params" "github.com/stretchr/testify/require" "github.com/ethereum/hive/hivesim" @@ -180,7 +180,7 @@ func runP2PTests(t *hivesim.T) { return } require.NoError(t, seqEthCl.SendTransaction(ctx, tx)) - _, err = optimism.WaitReceipt(ctx, seqEthCl, tx.Hash()) + _, err = optimism.WaitReceiptOK(ctx, seqEthCl, tx.Hash()) if err != nil { errCh <- err return diff --git a/simulators/optimism/rpc/abi.go b/simulators/optimism/rpc/abi.go index ae43001c7c..9f942fb0ba 100644 --- a/simulators/optimism/rpc/abi.go +++ b/simulators/optimism/rpc/abi.go @@ -1,6 +1,10 @@ package main import ( + "math/big" + "math/rand" + "strings" + "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" @@ -9,9 +13,6 @@ import ( "github.com/ethereum/go-ethereum/params" "github.com/ethereum/hive/optimism" "github.com/ethereum/hive/simulators/optimism/rpc/testcontract" - "math/big" - "math/rand" - "strings" ) //go:generate abigen -abi ./contractABI.json -pkg testcontract -type Contract -out ./testcontract/contract.go @@ -93,7 +94,7 @@ func transactContractTest(t *LegacyTestEnv) { // fetch transaction receipt for contract address var contractAddress common.Address - receipt, err := optimism.WaitReceipt(t.Ctx(), t.Eth, deployTx.Hash()) + receipt, err := optimism.WaitReceiptOK(t.Ctx(), t.Eth, deployTx.Hash()) if err != nil { t.Fatalf("Unable to retrieve receipt %v: %v", deployTx.Hash(), err) } @@ -124,7 +125,7 @@ func transactContractTest(t *LegacyTestEnv) { t.Logf("Waiting for receipt for events tx %v", tx.Hash()) // wait for transaction - receipt, err = optimism.WaitReceipt(t.Ctx(), t.Eth, tx.Hash()) + receipt, err = optimism.WaitReceiptOK(t.Ctx(), t.Eth, tx.Hash()) if err != nil { t.Fatalf("Unable to send transaction to events method: %v", err) } diff --git a/simulators/optimism/rpc/ethclient.go b/simulators/optimism/rpc/ethclient.go index 44ba87a2b6..26465fb9f6 100644 --- a/simulators/optimism/rpc/ethclient.go +++ b/simulators/optimism/rpc/ethclient.go @@ -2,12 +2,13 @@ package main import ( "bytes" - "github.com/ethereum/hive/optimism" "math/big" "math/rand" "strings" "time" + "github.com/ethereum/hive/optimism" + "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/common" @@ -126,7 +127,7 @@ func estimateGasTest(t *LegacyTestEnv) { t.Fatalf("Could not send tx: %v", err) } - receipt, err := optimism.WaitReceipt(t.Ctx(), t.Eth, tx.Hash()) + receipt, err := optimism.WaitReceiptOK(t.Ctx(), t.Eth, tx.Hash()) if err != nil { t.Fatalf("Could not wait for confirmations: %v", err) } @@ -291,7 +292,7 @@ func deployContractTest(t *LegacyTestEnv) { // fetch transaction receipt for contract address var contractAddress common.Address - receipt, err := optimism.WaitReceipt(t.Ctx(), t.Eth, deployTx.Hash()) + receipt, err := optimism.WaitReceiptOK(t.Ctx(), t.Eth, deployTx.Hash()) if err != nil { t.Fatalf("Unable to retrieve receipt %v: %v", deployTx.Hash(), err) } @@ -362,7 +363,7 @@ func deployContractOutOfGasTest(t *LegacyTestEnv) { } // Wait for the transaction receipt. - receipt, err := optimism.WaitReceipt(t.Ctx(), t.Eth, deployTx.Hash()) + receipt, err := optimism.WaitReceiptOK(t.Ctx(), t.Eth, deployTx.Hash()) if err != nil { t.Fatalf("unable to fetch tx receipt %v: %v", deployTx.Hash(), err) } @@ -416,7 +417,7 @@ func receiptTest(t *LegacyTestEnv) { } // wait for transaction - receipt, err := optimism.WaitReceipt(t.Ctx(), t.Eth, tx.Hash()) + receipt, err := optimism.WaitReceiptOK(t.Ctx(), t.Eth, tx.Hash()) if err != nil { t.Fatalf("Unable to retrieve tx receipt %v: %v", tx.Hash(), err) }