bump geth v1.14.11; rm hacks (#11809)

* bump geth v1.13.14; rm hack; fix simulated backend; run make generate

* Update simulated geth client wrapper & LogPoller tests (#13204)

* Re-run make generate, fix fluxmonitorv2 & ocr2keeper tests

* Update SimulatedBackendClient to wrap simulated.Backend & simulated.Client

( instead of deprecated backends.SimulatedBackendClient )

* Update LogPoller helper

* Add support for switching rpc clients in simulated geth

* Fix TestLogPoller_BackupPollAndSaveLogsSkippingLogsThatAreTooOld

This test relied on markBlockFinalized() which has been replaced
with finalizedBlocksThrough(). Just needed some slight adjustments
to keep testing the same thing.

* Fix TestLogPoller_ReorgDeeperThanFinality

* Fix Test_PollAndSavePersistsFinalityInBlocks

* Fix Test_PollAndQueryFinalizedBlocks

* update listener_v2_log_listener_test

* Fix chainreader & config poller tests

* Update keeper integration tests

* Re-run make generate

* Update BackupLogPoller test

Add RegisterHeadNumberCallback() to SimulatedBackendClient, so we can
trigger an rpc failover event just after reading a particular block, but
before the logs get read for that block. This is the race condition that
can happen on optimism chain which BackupPoller was designed to address

* .

* Update TestLogPoller_PollAndSaveLogsDeepReorg

* Not sure how this was working before

Presumably, the older verison of simulated.Backend would fill in fake timestamps
instead of real ones?

* Update TestLogPoller_PollAndSaveLogs

* Update TestLogPoller_Blocktimestamps

The new Simulated Geth made two changes which affected this test
1. The automatic time interval added to each new block is now 1ns instead of 1s
2. AdjustTime() now automatically calls Commit() so it no longer needs to be called aftewards

* Update TestLogPoller_BackupPollAndSaveLogsWithPollerNotWorking

* Address PR review comments

- Consolidate go-ethereum imports
- Remove extra geth-wrapper changes

* Update types in vrf tests

* Update keepers, fluxmointor, transmitter,ocr test types

* re-generate KeystoneForwarder

* Replace optimismMode with chainFamily enum

* Update more types GenesisAlloc, GenesisAccount, llo

* Fix some more compilation errors (fluxmonitor2, vrf, ocr2, functions)

* Fix lint errors, remove unused logpoller test definitions

* Run go-generate again on KeystoneForwarder

* Re-run "make generate" one more time, this time without any failures aside from the // error at the end that's in CI as well.

* Re-generate generation version db for keystone

* cleanup

* make generate

* cleanup

* race-free simulated backend commits

* race free commits

* fix tests by adding commits

* bump geth to 1.13.15

* fix more races

* Remove inconsistent named param from return signature

* insert temporary skips

* make generate

* skip more tests

* skip more tests; fill zeroed timestamp on insert

* fix race for commit

* core/services/ocr2/plugins/ocr2keeper/evmregistry/v21/logprovider: run log poller

* re-enable some tests

* consolidate finalization helpers

* fix some tests with real timestamps

* simplify

* core/services/vrf/solidity_cross_tests: raise gas estimate upper bound in TestMeasureRandomnessRequestGasCost

* cleanup and patch for geth bug

* new geth error; vrf test fixes

* fix ccip tests

* fix clo tests

* more fixes

* fix test var name

* fix compile error

* upgrade to 14.7

* fix lint

* lint issues

* make generate

* fix more tests

* skip failing tests

* skip tests; linter issues

* fix race & lint issues

* BCFR-1047 Fix HT Tests (#14807)

* Simulated defaults (#14986)

* Simulated defaults

* Direct request works

* Fix config tests

* AsyncEthTx

* OCR + FM

* Keepers

* Functions

* Bunch of keeper and VRF tests

* More vrf tests

* Cleanup

* Fix a race

* core/chains/evm/txmgr: fix TestEthBroadcaster_ProcessUnstartedEthTxs_OptimisticLockingOnEthTx

* core/gethwrappers: regenerate

* bump geth to 1.14.11 (#15041)

* bump geth to 1.14.11

* remove AdjustTime hacks

* Try replace in integration tests

* Copy replace around

* Preserve fork behaviour

* generate

* tidy

* Work around geth, fix timestamp test

* Fix docstring

* Fix reader test

* Linter

* Re-enable CCIP deployment tests

* Mod + lint

* Remove cltest dependency which invokes pgtest init

---------

Co-authored-by: connorwstein <[email protected]>

* Another cltest remove

* Go mod tidy

* Regen lint and fix LLO test

* Enable some more tests

* core: prefer simulated backend interface in order to wrap with syncBackend

* fix race: cleanup int conversion

* lint

* lint & fix

* lint

* lint

* unskip and fix

* Fix TestIntegration_OCR2_plugins

* Fix more OCR tests

* update t.Skip() messages

* update changeset

* Resurrect CCIP tests

* Lint

* replaces

* lint

---------

Co-authored-by: Domino Valdano <[email protected]>
Co-authored-by: Domino Valdano <[email protected]>
Co-authored-by: AnieeG <[email protected]>
Co-authored-by: Dmytro Haidashenko <[email protected]>
Co-authored-by: Connor Stein <[email protected]>

.changeset/purple-shrimps-invent.md

@@ -0,0 +1,5 @@
+---
+"chainlink": patch
+---
+
+Upgrade go-ethereum to v1.14.11 #internal

.changeset/silent-goats-jog.md

@@ -0,0 +1,5 @@
+---
+"chainlink": patch
+---
+
+Fix HeadTracker tests caused by simulated client update #internal

.tool-versions

@@ -6,3 +6,4 @@ postgres 15.1
 helm 3.10.3
 golangci-lint 1.61.0
 protoc 25.1
+python 3.10.5

common/txmgr/broadcaster.go

@@ -603,7 +603,7 @@ func (eb *Broadcaster[CHAIN_ID, HEAD, ADDR, TX_HASH, BLOCK_HASH, SEQ, FEE]) hand
 	case client.Unknown:
 		eb.SvcErrBuffer.Append(err)
 		lgr.Criticalw(`Unknown error occurred while handling tx queue in ProcessUnstartedTxs. This chain/RPC client may not be supported. `+
-			`Urgent resolution required, Chainlink is currently operating in a degraded state and may miss transactions`, "attempt", attempt)
+			`Urgent resolution required, Chainlink is currently operating in a degraded state and may miss transactions`, "attempt", attempt, "err", err)
 		nextSequence, e := eb.client.PendingSequenceAt(ctx, etx.FromAddress)
 		if e != nil {
 			err = multierr.Combine(e, err)

core/capabilities/ccip/ccip_integration_tests/ccipreader/ccipreader_test.go

@@ -8,10 +8,10 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core"
+	ethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethclient/simulated"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/zap/zapcore"
@@ -79,6 +79,7 @@ func TestCCIPReader_CommitReportsGTETimestamp(t *testing.T) {
 	tokenA := common.HexToAddress("123")
 	const numReports = 5
 
+	var firstReportTs uint64
 	for i := 0; i < numReports; i++ {
 		_, err := s.contract.EmitCommitReportAccepted(s.auth, ccip_reader_tester.OffRampCommitReport{
 			PriceUpdates: ccip_reader_tester.InternalPriceUpdates{
@@ -116,7 +117,12 @@ func TestCCIPReader_CommitReportsGTETimestamp(t *testing.T) {
 			},
 		})
 		assert.NoError(t, err)
-		s.sb.Commit()
+		bh := s.sb.Commit()
+		b, err := s.sb.Client().BlockByHash(ctx, bh)
+		require.NoError(t, err)
+		if firstReportTs == 0 {
+			firstReportTs = b.Time()
+		}
 	}
 
 	// Need to replay as sometimes the logs are not picked up by the log poller (?)
@@ -129,7 +135,9 @@ func TestCCIPReader_CommitReportsGTETimestamp(t *testing.T) {
 		reports, err = s.reader.CommitReportsGTETimestamp(
 			ctx,
 			chainD,
-			time.Unix(30, 0), // Skips first report, simulated backend report timestamps are [20, 30, 40, ...]
+			// Skips first report
+			//nolint:gosec // this won't overflow
+			time.Unix(int64(firstReportTs)+1, 0),
 			10,
 		)
 		require.NoError(t, err)
@@ -144,10 +152,8 @@ func TestCCIPReader_CommitReportsGTETimestamp(t *testing.T) {
 	assert.Equal(t, cciptypes.SeqNum(20), reports[0].Report.MerkleRoots[0].SeqNumsRange.End())
 	assert.Equal(t, "0x0200000000000000000000000000000000000000000000000000000000000000",
 		reports[0].Report.MerkleRoots[0].MerkleRoot.String())
-
 	assert.Equal(t, tokenA.String(), string(reports[0].Report.PriceUpdates.TokenPriceUpdates[0].TokenID))
 	assert.Equal(t, uint64(1000), reports[0].Report.PriceUpdates.TokenPriceUpdates[0].Price.Uint64())
-
 	assert.Equal(t, chainD, reports[0].Report.PriceUpdates.GasPriceUpdates[0].ChainSel)
 	assert.Equal(t, uint64(90), reports[0].Report.PriceUpdates.GasPriceUpdates[0].GasPrice.Uint64())
 }
@@ -478,21 +484,21 @@ func testSetup(
 	// Set up the genesis account with balance
 	blnc, ok := big.NewInt(0).SetString("999999999999999999999999999999999999", 10)
 	assert.True(t, ok)
-	alloc := map[common.Address]core.GenesisAccount{crypto.PubkeyToAddress(privateKey.PublicKey): {Balance: blnc}}
-	simulatedBackend := backends.NewSimulatedBackend(alloc, 0)
+	alloc := map[common.Address]ethtypes.Account{crypto.PubkeyToAddress(privateKey.PublicKey): {Balance: blnc}}
+	simulatedBackend := simulated.NewBackend(alloc, simulated.WithBlockGasLimit(0))
 	// Create a transactor
 
 	auth, err := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(chainID))
 	assert.NoError(t, err)
 	auth.GasLimit = uint64(0)
 
 	// Deploy the contract
-	address, _, _, err := ccip_reader_tester.DeployCCIPReaderTester(auth, simulatedBackend)
+	address, _, _, err := ccip_reader_tester.DeployCCIPReaderTester(auth, simulatedBackend.Client())
 	assert.NoError(t, err)
 	simulatedBackend.Commit()
 
 	// Setup contract client
-	contract, err := ccip_reader_tester.NewCCIPReaderTester(address, simulatedBackend)
+	contract, err := ccip_reader_tester.NewCCIPReaderTester(address, simulatedBackend.Client())
 	assert.NoError(t, err)
 
 	lggr := logger.TestLogger(t)
@@ -582,7 +588,7 @@ func testSetup(
 type testSetupData struct {
 	contractAddr common.Address
 	contract     *ccip_reader_tester.CCIPReaderTester
-	sb           *backends.SimulatedBackend
+	sb           *simulated.Backend
 	auth         *bind.TransactOpts
 	lp           logpoller.LogPoller
 	cl           client.Client

core/capabilities/ccip/ccip_integration_tests/integrationhelpers/integration_helpers.go

@@ -12,16 +12,18 @@ import (
 	"time"
 
 	mapset "github.com/deckarep/golang-set/v2"
-
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core"
+	ethtypes "github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient/simulated"
 	"github.com/stretchr/testify/require"
 
 	"github.com/smartcontractkit/chainlink-ccip/pkg/consts"
 	ccipreader "github.com/smartcontractkit/chainlink-ccip/pkg/reader"
 	"github.com/smartcontractkit/chainlink-ccip/pkg/types/ccipocr3"
+	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/ccip_home"
+	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/rmn_home"
+
 	"github.com/smartcontractkit/chainlink-common/pkg/types"
 
 	configsevm "github.com/smartcontractkit/chainlink/v2/core/capabilities/ccip/configs/evm"
@@ -30,8 +32,6 @@ import (
 	"github.com/smartcontractkit/chainlink/v2/core/chains/evm/client"
 	"github.com/smartcontractkit/chainlink/v2/core/chains/evm/headtracker"
 	"github.com/smartcontractkit/chainlink/v2/core/chains/evm/logpoller"
-	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/ccip_home"
-	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/rmn_home"
 	kcr "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/keystone/generated/capabilities_registry"
 	"github.com/smartcontractkit/chainlink/v2/core/internal/testutils"
 	"github.com/smartcontractkit/chainlink/v2/core/internal/testutils/pgtest"
@@ -88,7 +88,7 @@ const (
 
 type TestUniverse struct {
 	Transactor         *bind.TransactOpts
-	Backend            *backends.SimulatedBackend
+	Backend            *simulated.Backend
 	CapReg             *kcr.CapabilitiesRegistry
 	CCIPHome           *ccip_home.CCIPHome
 	TestingT           *testing.T
@@ -101,22 +101,22 @@ type TestUniverse struct {
 
 func NewTestUniverse(ctx context.Context, t *testing.T, lggr logger.Logger) TestUniverse {
 	transactor := testutils.MustNewSimTransactor(t)
-	backend := backends.NewSimulatedBackend(core.GenesisAlloc{
+	backend := simulated.NewBackend(ethtypes.GenesisAlloc{
 		transactor.From: {Balance: assets.Ether(1000).ToInt()},
-	}, 30e6)
+	}, simulated.WithBlockGasLimit(30e6))
 
-	crAddress, _, _, err := kcr.DeployCapabilitiesRegistry(transactor, backend)
+	crAddress, _, _, err := kcr.DeployCapabilitiesRegistry(transactor, backend.Client())
 	require.NoError(t, err)
 	backend.Commit()
 
-	capReg, err := kcr.NewCapabilitiesRegistry(crAddress, backend)
+	capReg, err := kcr.NewCapabilitiesRegistry(crAddress, backend.Client())
 	require.NoError(t, err)
 
-	ccAddress, _, _, err := ccip_home.DeployCCIPHome(transactor, backend, crAddress)
+	ccAddress, _, _, err := ccip_home.DeployCCIPHome(transactor, backend.Client(), crAddress)
 	require.NoError(t, err)
 	backend.Commit()
 
-	cc, err := ccip_home.NewCCIPHome(ccAddress, backend)
+	cc, err := ccip_home.NewCCIPHome(ccAddress, backend.Client())
 	require.NoError(t, err)
 
 	db := pgtest.NewSqlxDB(t)

core/capabilities/ccip/ccip_integration_tests/rmn/rmn_home_test.go

@@ -40,7 +40,7 @@ func TestRMNHomeReader_GetRMNNodesInfo(t *testing.T) {
 	)
 
 	// ================================Deploy and configure RMNHome===============================
-	rmnHomeAddress, _, rmnHome, err := rmn_home.DeployRMNHome(uni.Transactor, uni.Backend)
+	rmnHomeAddress, _, rmnHome, err := rmn_home.DeployRMNHome(uni.Transactor, uni.Backend.Client())
 	require.NoError(t, err)
 	uni.Backend.Commit()
 

core/capabilities/ccip/ccip_integration_tests/usdcreader/usdcreader_test.go

@@ -7,10 +7,10 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core"
+	gethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethclient/simulated"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -228,8 +228,8 @@ func testSetup(ctx context.Context, t *testing.T, readerChain cciptypes.ChainSel
 	// Set up the genesis account with balance
 	blnc, ok := big.NewInt(0).SetString("999999999999999999999999999999999999", 10)
 	assert.True(t, ok)
-	alloc := map[common.Address]core.GenesisAccount{crypto.PubkeyToAddress(privateKey.PublicKey): {Balance: blnc}}
-	simulatedBackend := backends.NewSimulatedBackend(alloc, 0)
+	alloc := map[common.Address]gethtypes.Account{crypto.PubkeyToAddress(privateKey.PublicKey): {Balance: blnc}}
+	simulatedBackend := simulated.NewBackend(alloc, simulated.WithBlockGasLimit(0))
 	// Create a transactor
 
 	auth, err := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(chainID))
@@ -238,12 +238,12 @@ func testSetup(ctx context.Context, t *testing.T, readerChain cciptypes.ChainSel
 
 	address, _, _, err := usdc_reader_tester.DeployUSDCReaderTester(
 		auth,
-		simulatedBackend,
+		simulatedBackend.Client(),
 	)
 	require.NoError(t, err)
 	simulatedBackend.Commit()
 
-	contract, err := usdc_reader_tester.NewUSDCReaderTester(address, simulatedBackend)
+	contract, err := usdc_reader_tester.NewUSDCReaderTester(address, simulatedBackend.Client())
 	require.NoError(t, err)
 
 	lggr := logger.TestLogger(t)
@@ -292,7 +292,7 @@ func testSetup(ctx context.Context, t *testing.T, readerChain cciptypes.ChainSel
 type testSetupData struct {
 	contractAddr common.Address
 	contract     *usdc_reader_tester.USDCReaderTester
-	sb           *backends.SimulatedBackend
+	sb           *simulated.Backend
 	auth         *bind.TransactOpts
 	cl           client.Client
 	reader       types.ContractReader

core/capabilities/ccip/ocrimpls/contract_transmitter_test.go

@@ -7,18 +7,11 @@ import (
 	"testing"
 	"time"
 
-	"github.com/smartcontractkit/chainlink-common/pkg/utils/tests"
-
-	"github.com/smartcontractkit/chainlink/v2/core/capabilities/ccip/ocrimpls"
-	cctypes "github.com/smartcontractkit/chainlink/v2/core/capabilities/ccip/types"
-	"github.com/smartcontractkit/chainlink/v2/core/chains/evm/config/toml"
-	"github.com/smartcontractkit/chainlink/v2/core/chains/evm/types"
-
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient/simulated"
 	"github.com/jmoiron/sqlx"
 	"github.com/stretchr/testify/require"
 
@@ -27,7 +20,12 @@ import (
 	ocrtypes "github.com/smartcontractkit/libocr/offchainreporting2plus/types"
 
 	"github.com/smartcontractkit/chainlink-common/pkg/utils/mailbox"
+	"github.com/smartcontractkit/chainlink-common/pkg/utils/tests"
+	"github.com/smartcontractkit/chainlink/v2/core/chains/evm/config/toml"
+	evmtypes "github.com/smartcontractkit/chainlink/v2/core/chains/evm/types"
 
+	"github.com/smartcontractkit/chainlink/v2/core/capabilities/ccip/ocrimpls"
+	cctypes "github.com/smartcontractkit/chainlink/v2/core/capabilities/ccip/types"
 	"github.com/smartcontractkit/chainlink/v2/core/chains/evm/assets"
 	"github.com/smartcontractkit/chainlink/v2/core/chains/evm/client"
 	evmconfig "github.com/smartcontractkit/chainlink/v2/core/chains/evm/config"
@@ -182,7 +180,7 @@ func testTransmitter(
 
 type testUniverse[RI any] struct {
 	simClient              *client.SimulatedBackendClient
-	backend                *backends.SimulatedBackend
+	backend                *simulated.Backend
 	deployer               *bind.TransactOpts
 	transmitters           []common.Address
 	signers                []common.Address
@@ -217,19 +215,19 @@ func newTestUniverse[RI any](t *testing.T, ks *keyringsAndSigners[RI]) *testUniv
 		transmitters = append(transmitters, key.Address)
 	}
 
-	backend := backends.NewSimulatedBackend(core.GenesisAlloc{
-		owner.From: core.GenesisAccount{
+	backend := simulated.NewBackend(types.GenesisAlloc{
+		owner.From: types.Account{
 			Balance: assets.Ether(1000).ToInt(),
 		},
-		transmitters[0]: core.GenesisAccount{
+		transmitters[0]: types.Account{
 			Balance: assets.Ether(1000).ToInt(),
 		},
-	}, 30e6)
+	}, simulated.WithBlockGasLimit(30e6))
 
-	ocr3HelperAddr, _, _, err := multi_ocr3_helper.DeployMultiOCR3Helper(owner, backend)
+	ocr3HelperAddr, _, _, err := multi_ocr3_helper.DeployMultiOCR3Helper(owner, backend.Client())
 	require.NoError(t, err)
 	backend.Commit()
-	wrapper, err := multi_ocr3_helper.NewMultiOCR3Helper(ocr3HelperAddr, backend)
+	wrapper, err := multi_ocr3_helper.NewMultiOCR3Helper(ocr3HelperAddr, backend.Client())
 	require.NoError(t, err)
 
 	// create the oracle identities for setConfig
@@ -605,8 +603,8 @@ func (d *TestDAOracleConfig) OracleType() *toml.DAOracleType {
 	return &oracleType
 }
 
-func (d *TestDAOracleConfig) OracleAddress() *types.EIP55Address {
-	a, err := types.NewEIP55Address("0x420000000000000000000000000000000000000F")
+func (d *TestDAOracleConfig) OracleAddress() *evmtypes.EIP55Address {
+	a, err := evmtypes.NewEIP55Address("0x420000000000000000000000000000000000000F")
 	if err != nil {
 		panic(err)
 	}

core/capabilities/integration_tests/framework/capabilities_registry.go

@@ -2,6 +2,7 @@ package framework
 
 import (
 	"context"
+	"testing"
 
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
@@ -12,8 +13,6 @@ import (
 	"github.com/smartcontractkit/chainlink-common/pkg/values"
 	kcr "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/keystone/generated/capabilities_registry"
 
-	"testing"
-
 	"github.com/stretchr/testify/require"
 )
 
@@ -27,7 +26,7 @@ type CapabilitiesRegistry struct {
 }
 
 func NewCapabilitiesRegistry(ctx context.Context, t *testing.T, backend *EthBlockchain) *CapabilitiesRegistry {
-	addr, _, contract, err := kcr.DeployCapabilitiesRegistry(backend.transactionOpts, backend)
+	addr, _, contract, err := kcr.DeployCapabilitiesRegistry(backend.transactionOpts, backend.Client())
 	require.NoError(t, err)
 	backend.Commit()
 
@@ -40,7 +39,7 @@ func NewCapabilitiesRegistry(ctx context.Context, t *testing.T, backend *EthBloc
 	require.NoError(t, err)
 	blockHash := backend.Commit()
 
-	logs, err := backend.FilterLogs(ctx, ethereum.FilterQuery{
+	logs, err := backend.Client().FilterLogs(ctx, ethereum.FilterQuery{
 		BlockHash: &blockHash,
 		FromBlock: nil,
 		ToBlock:   nil,

core/capabilities/integration_tests/framework/don.go

@@ -292,7 +292,7 @@ func startNewNode(ctx context.Context,
 		}
 	})
 
-	n, err := ethBlockchain.NonceAt(ctx, ethBlockchain.transactionOpts.From, nil)
+	n, err := ethBlockchain.Client().NonceAt(ctx, ethBlockchain.transactionOpts.From, nil)
 	require.NoError(t, err)
 
 	tx := cltest.NewLegacyTransaction(
@@ -303,11 +303,11 @@ func startNewNode(ctx context.Context,
 		nil)
 	signedTx, err := ethBlockchain.transactionOpts.Signer(ethBlockchain.transactionOpts.From, tx)
 	require.NoError(t, err)
-	err = ethBlockchain.SendTransaction(ctx, signedTx)
+	err = ethBlockchain.Client().SendTransaction(ctx, signedTx)
 	require.NoError(t, err)
 	ethBlockchain.Commit()
 
-	return cltest.NewApplicationWithConfigV2AndKeyOnSimulatedBlockchain(t, config, ethBlockchain.SimulatedBackend, nodeInfo,
+	return cltest.NewApplicationWithConfigV2AndKeyOnSimulatedBlockchain(t, config, ethBlockchain.Backend, nodeInfo,
 		dispatcher, peerWrapper, newOracleFactoryFn, localCapabilities, keyV2, lggr)
 }