bump geth v1.14.11; rm hacks

.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)
 }