diff --git a/.changeset/curly-onions-tell.md b/.changeset/curly-onions-tell.md
new file mode 100644
index 00000000000..249f616c012
--- /dev/null
+++ b/.changeset/curly-onions-tell.md
@@ -0,0 +1,5 @@
+---
+"chainlink": patch
+---
+
+#changed Make Mantle use default OP stack l1 gas oracle in core
diff --git a/.github/E2E_TESTS_ON_GITHUB_CI.md b/.github/E2E_TESTS_ON_GITHUB_CI.md
index f3a279338df..572e0070a05 100644
--- a/.github/E2E_TESTS_ON_GITHUB_CI.md
+++ b/.github/E2E_TESTS_ON_GITHUB_CI.md
@@ -49,9 +49,9 @@ To learn more about test configs see [CTF Test Config](https://github.com/smartc
 
 ## Test Secrets
 
-For security reasons, test secrets and sensitive information are not stored directly within the test config TOML files. Instead, these secrets are securely injected into tests using environment variables. For a detailed explanation on managing test secrets, refer to our [Test Secrets documentation](https://github.com/smartcontractkit/chainlink-testing-framework/blob/main/config/README.md#test-secrets).
+For security reasons, test secrets and sensitive information are not stored directly within the test config TOML files. Instead, these secrets are securely injected into tests using environment variables. For a detailed explanation on managing test secrets, refer to our [Test Secrets documentation](https://github.com/smartcontractkit/chainlink-testing-framework/blob/main/lib/config/README.md#test-secrets).
 
-If you need to run a GitHub workflow using custom secrets, please refer to the [guide on running GitHub workflows with your test secrets](https://github.com/smartcontractkit/chainlink-testing-framework/blob/main/config/README.md#run-github-workflow-with-your-test-secrets).
+If you need to run a GitHub workflow using custom secrets, please refer to the [guide on running GitHub workflows with your test secrets](https://github.com/smartcontractkit/chainlink-testing-framework/blob/main/lib/config/README.md#run-github-workflow-with-your-test-secrets).
 
 ## About the Reusable Workflow
 
diff --git a/core/chains/evm/gas/rollups/arbitrum_l1_oracle.go b/core/chains/evm/gas/rollups/arbitrum_l1_oracle.go
index c01244db70c..d758dc711e9 100644
--- a/core/chains/evm/gas/rollups/arbitrum_l1_oracle.go
+++ b/core/chains/evm/gas/rollups/arbitrum_l1_oracle.go
@@ -112,6 +112,10 @@ func (o *arbitrumL1Oracle) Name() string {
 	return o.logger.Name()
 }
 
+func (o *arbitrumL1Oracle) ChainType(_ context.Context) chaintype.ChainType {
+	return o.chainType
+}
+
 func (o *arbitrumL1Oracle) Start(ctx context.Context) error {
 	return o.StartOnce(o.Name(), func() error {
 		go o.run()
diff --git a/core/chains/evm/gas/rollups/l1_oracle.go b/core/chains/evm/gas/rollups/l1_oracle.go
index e1249fdb7e9..41951755986 100644
--- a/core/chains/evm/gas/rollups/l1_oracle.go
+++ b/core/chains/evm/gas/rollups/l1_oracle.go
@@ -26,6 +26,7 @@ type L1Oracle interface {
 
 	GasPrice(ctx context.Context) (*assets.Wei, error)
 	GetGasCost(ctx context.Context, tx *types.Transaction, blockNum *big.Int) (*assets.Wei, error)
+	ChainType(ctx context.Context) chaintype.ChainType
 }
 
 type l1OracleClient interface {
diff --git a/core/chains/evm/gas/rollups/l1_oracle_abi.go b/core/chains/evm/gas/rollups/l1_oracle_abi.go
index 848957ce53a..fa5d9c85391 100644
--- a/core/chains/evm/gas/rollups/l1_oracle_abi.go
+++ b/core/chains/evm/gas/rollups/l1_oracle_abi.go
@@ -19,4 +19,3 @@ const OPBaseFeeScalarAbiString = `[{"inputs":[],"name":"baseFeeScalar","outputs"
 const OPBlobBaseFeeAbiString = `[{"inputs":[],"name":"blobBaseFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]`
 const OPBlobBaseFeeScalarAbiString = `[{"inputs":[],"name":"blobBaseFeeScalar","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"}]`
 const OPDecimalsAbiString = `[{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}]`
-const MantleTokenRatioAbiString = `[{"inputs":[],"name":"tokenRatio","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]`
diff --git a/core/chains/evm/gas/rollups/mocks/l1_oracle.go b/core/chains/evm/gas/rollups/mocks/l1_oracle.go
index e82cb4ee903..25bb3a2db59 100644
--- a/core/chains/evm/gas/rollups/mocks/l1_oracle.go
+++ b/core/chains/evm/gas/rollups/mocks/l1_oracle.go
@@ -7,6 +7,8 @@ import (
 
 	assets "github.com/smartcontractkit/chainlink/v2/core/chains/evm/assets"
 
+	chaintype "github.com/smartcontractkit/chainlink/v2/core/chains/evm/config/chaintype"
+
 	context "context"
 
 	mock "github.com/stretchr/testify/mock"
@@ -27,6 +29,52 @@ func (_m *L1Oracle) EXPECT() *L1Oracle_Expecter {
 	return &L1Oracle_Expecter{mock: &_m.Mock}
 }
 
+// ChainType provides a mock function with given fields: ctx
+func (_m *L1Oracle) ChainType(ctx context.Context) chaintype.ChainType {
+	ret := _m.Called(ctx)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ChainType")
+	}
+
+	var r0 chaintype.ChainType
+	if rf, ok := ret.Get(0).(func(context.Context) chaintype.ChainType); ok {
+		r0 = rf(ctx)
+	} else {
+		r0 = ret.Get(0).(chaintype.ChainType)
+	}
+
+	return r0
+}
+
+// L1Oracle_ChainType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChainType'
+type L1Oracle_ChainType_Call struct {
+	*mock.Call
+}
+
+// ChainType is a helper method to define mock.On call
+//   - ctx context.Context
+func (_e *L1Oracle_Expecter) ChainType(ctx interface{}) *L1Oracle_ChainType_Call {
+	return &L1Oracle_ChainType_Call{Call: _e.mock.On("ChainType", ctx)}
+}
+
+func (_c *L1Oracle_ChainType_Call) Run(run func(ctx context.Context)) *L1Oracle_ChainType_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context))
+	})
+	return _c
+}
+
+func (_c *L1Oracle_ChainType_Call) Return(_a0 chaintype.ChainType) *L1Oracle_ChainType_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *L1Oracle_ChainType_Call) RunAndReturn(run func(context.Context) chaintype.ChainType) *L1Oracle_ChainType_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // Close provides a mock function with given fields:
 func (_m *L1Oracle) Close() error {
 	ret := _m.Called()
diff --git a/core/chains/evm/gas/rollups/op_l1_oracle.go b/core/chains/evm/gas/rollups/op_l1_oracle.go
index 1b93f8fc3f9..11babc5ca5d 100644
--- a/core/chains/evm/gas/rollups/op_l1_oracle.go
+++ b/core/chains/evm/gas/rollups/op_l1_oracle.go
@@ -88,10 +88,6 @@ const (
 	// decimals is a hex encoded call to:
 	// `function decimals() public pure returns (uint256);`
 	decimalsMethod = "decimals"
-	// tokenRatio fetches the tokenRatio used for Mantle's gas price calculation
-	// tokenRatio is a hex encoded call to:
-	// `function tokenRatio() public pure returns (uint256);`
-	tokenRatioMethod = "tokenRatio"
 	// OPGasOracleAddress is the address of the precompiled contract that exists on Optimism, Base and Mantle.
 	OPGasOracleAddress = "0x420000000000000000000000000000000000000F"
 	// KromaGasOracleAddress is the address of the precompiled contract that exists on Kroma.
@@ -192,16 +188,6 @@ func newOpStackL1GasOracle(lggr logger.Logger, ethClient l1OracleClient, chainTy
 		return nil, fmt.Errorf("failed to parse GasPriceOracle %s() calldata for chain: %s; %w", decimalsMethod, chainType, err)
 	}
 
-	// Encode calldata for tokenRatio method
-	tokenRatioMethodAbi, err := abi.JSON(strings.NewReader(MantleTokenRatioAbiString))
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse GasPriceOracle %s() method ABI for chain: %s; %w", tokenRatioMethod, chainType, err)
-	}
-	tokenRatioCalldata, err := tokenRatioMethodAbi.Pack(tokenRatioMethod)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse GasPriceOracle %s() calldata for chain: %s; %w", tokenRatioMethod, chainType, err)
-	}
-
 	return &optimismL1Oracle{
 		client:     ethClient,
 		pollPeriod: PollPeriod,
@@ -223,7 +209,6 @@ func newOpStackL1GasOracle(lggr logger.Logger, ethClient l1OracleClient, chainTy
 		blobBaseFeeCalldata:       blobBaseFeeCalldata,
 		blobBaseFeeScalarCalldata: blobBaseFeeScalarCalldata,
 		decimalsCalldata:          decimalsCalldata,
-		tokenRatioCalldata:        tokenRatioCalldata,
 		isEcotoneCalldata:         isEcotoneCalldata,
 		isEcotoneMethodAbi:        isEcotoneMethodAbi,
 		isFjordCalldata:           isFjordCalldata,
@@ -235,6 +220,10 @@ func (o *optimismL1Oracle) Name() string {
 	return o.logger.Name()
 }
 
+func (o *optimismL1Oracle) ChainType(_ context.Context) chaintype.ChainType {
+	return o.chainType
+}
+
 func (o *optimismL1Oracle) Start(ctx context.Context) error {
 	return o.StartOnce(o.Name(), func() error {
 		go o.run()
@@ -362,10 +351,6 @@ func (o *optimismL1Oracle) GetGasCost(ctx context.Context, tx *gethtypes.Transac
 }
 
 func (o *optimismL1Oracle) GetDAGasPrice(ctx context.Context) (*big.Int, error) {
-	if o.chainType == chaintype.ChainMantle {
-		return o.getMantleGasPrice(ctx)
-	}
-
 	err := o.checkForUpgrade(ctx)
 	if err != nil {
 		return nil, err
@@ -463,69 +448,6 @@ func (o *optimismL1Oracle) getV1GasPrice(ctx context.Context) (*big.Int, error)
 	return new(big.Int).SetBytes(b), nil
 }
 
-// Returns the gas price for Mantle. The formula is the same as Optimism Bedrock (getV1GasPrice), but the tokenRatio parameter is multiplied
-func (o *optimismL1Oracle) getMantleGasPrice(ctx context.Context) (*big.Int, error) {
-	// call oracle to get l1BaseFee and tokenRatio
-	rpcBatchCalls := []rpc.BatchElem{
-		{
-			Method: "eth_call",
-			Args: []any{
-				map[string]interface{}{
-					"from": common.Address{},
-					"to":   o.l1OracleAddress,
-					"data": hexutil.Bytes(o.l1BaseFeeCalldata),
-				},
-				"latest",
-			},
-			Result: new(string),
-		},
-		{
-			Method: "eth_call",
-			Args: []any{
-				map[string]interface{}{
-					"from": common.Address{},
-					"to":   o.l1OracleAddress,
-					"data": hexutil.Bytes(o.tokenRatioCalldata),
-				},
-				"latest",
-			},
-			Result: new(string),
-		},
-	}
-
-	err := o.client.BatchCallContext(ctx, rpcBatchCalls)
-	if err != nil {
-		return nil, fmt.Errorf("fetch gas price parameters batch call failed: %w", err)
-	}
-	if rpcBatchCalls[0].Error != nil {
-		return nil, fmt.Errorf("%s call failed in a batch: %w", l1BaseFeeMethod, err)
-	}
-	if rpcBatchCalls[1].Error != nil {
-		return nil, fmt.Errorf("%s call failed in a batch: %w", tokenRatioMethod, err)
-	}
-
-	// Extract values from responses
-	l1BaseFeeResult := *(rpcBatchCalls[0].Result.(*string))
-	tokenRatioResult := *(rpcBatchCalls[1].Result.(*string))
-
-	// Decode the responses into bytes
-	l1BaseFeeBytes, err := hexutil.Decode(l1BaseFeeResult)
-	if err != nil {
-		return nil, fmt.Errorf("failed to decode %s rpc result: %w", l1BaseFeeMethod, err)
-	}
-	tokenRatioBytes, err := hexutil.Decode(tokenRatioResult)
-	if err != nil {
-		return nil, fmt.Errorf("failed to decode %s rpc result: %w", tokenRatioMethod, err)
-	}
-
-	// Convert bytes to big int for calculations
-	l1BaseFee := new(big.Int).SetBytes(l1BaseFeeBytes)
-	tokenRatio := new(big.Int).SetBytes(tokenRatioBytes)
-
-	// multiply l1BaseFee and tokenRatio and return
-	return new(big.Int).Mul(l1BaseFee, tokenRatio), nil
-}
-
 // Returns the scaled gas price using baseFeeScalar, l1BaseFee, blobBaseFeeScalar, and blobBaseFee fields from the oracle
 // Confirmed the same calculation is used to determine gas price for both Ecotone and Fjord
 func (o *optimismL1Oracle) getEcotoneFjordGasPrice(ctx context.Context) (*big.Int, error) {
diff --git a/core/chains/evm/gas/rollups/op_l1_oracle_test.go b/core/chains/evm/gas/rollups/op_l1_oracle_test.go
index 88bb96534d3..f5f009f1ea6 100644
--- a/core/chains/evm/gas/rollups/op_l1_oracle_test.go
+++ b/core/chains/evm/gas/rollups/op_l1_oracle_test.go
@@ -111,94 +111,6 @@ func TestOPL1Oracle_ReadV1GasPrice(t *testing.T) {
 	}
 }
 
-func TestOPL1Oracle_ReadMantleGasPrice(t *testing.T) {
-	l1BaseFee := big.NewInt(100)
-	tokenRatio := big.NewInt(40)
-	oracleAddress := common.HexToAddress("0x1234").String()
-
-	t.Parallel()
-	t.Run("correctly fetches gas price if chain is Mantle", func(t *testing.T) {
-		// Encode calldata for l1BaseFee method
-		l1BaseFeeMethodAbi, err := abi.JSON(strings.NewReader(L1BaseFeeAbiString))
-		require.NoError(t, err)
-		l1BaseFeeCalldata, err := l1BaseFeeMethodAbi.Pack(l1BaseFeeMethod)
-		require.NoError(t, err)
-
-		// Encode calldata for tokenRatio method
-		tokenRatioMethodAbi, err := abi.JSON(strings.NewReader(MantleTokenRatioAbiString))
-		require.NoError(t, err)
-		tokenRatioCalldata, err := tokenRatioMethodAbi.Pack(tokenRatioMethod)
-		require.NoError(t, err)
-
-		ethClient := mocks.NewL1OracleClient(t)
-		ethClient.On("BatchCallContext", mock.Anything, mock.IsType([]rpc.BatchElem{})).Run(func(args mock.Arguments) {
-			rpcElements := args.Get(1).([]rpc.BatchElem)
-			require.Equal(t, 2, len(rpcElements))
-			for _, rE := range rpcElements {
-				require.Equal(t, "eth_call", rE.Method)
-				require.Equal(t, oracleAddress, rE.Args[0].(map[string]interface{})["to"])
-				require.Equal(t, "latest", rE.Args[1])
-			}
-			require.Equal(t, hexutil.Bytes(l1BaseFeeCalldata), rpcElements[0].Args[0].(map[string]interface{})["data"])
-			require.Equal(t, hexutil.Bytes(tokenRatioCalldata), rpcElements[1].Args[0].(map[string]interface{})["data"])
-
-			res1 := common.BigToHash(l1BaseFee).Hex()
-			res2 := common.BigToHash(tokenRatio).Hex()
-
-			rpcElements[0].Result = &res1
-			rpcElements[1].Result = &res2
-		}).Return(nil).Once()
-
-		oracle, err := newOpStackL1GasOracle(logger.Test(t), ethClient, chaintype.ChainMantle, oracleAddress)
-		require.NoError(t, err)
-
-		gasPrice, err := oracle.GetDAGasPrice(tests.Context(t))
-		require.NoError(t, err)
-
-		assert.Equal(t, new(big.Int).Mul(l1BaseFee, tokenRatio), gasPrice)
-	})
-
-	t.Run("fetching Mantle price but rpc returns bad data", func(t *testing.T) {
-		ethClient := mocks.NewL1OracleClient(t)
-		ethClient.On("BatchCallContext", mock.Anything, mock.IsType([]rpc.BatchElem{})).Run(func(args mock.Arguments) {
-			rpcElements := args.Get(1).([]rpc.BatchElem)
-			var badData = "zzz"
-			rpcElements[0].Result = &badData
-			rpcElements[1].Result = &badData
-		}).Return(nil).Once()
-
-		oracle, err := newOpStackL1GasOracle(logger.Test(t), ethClient, chaintype.ChainMantle, oracleAddress)
-		require.NoError(t, err)
-		_, err = oracle.GetDAGasPrice(tests.Context(t))
-		assert.Error(t, err)
-	})
-
-	t.Run("fetching Mantle price but rpc parent call errors", func(t *testing.T) {
-		ethClient := mocks.NewL1OracleClient(t)
-		ethClient.On("BatchCallContext", mock.Anything, mock.IsType([]rpc.BatchElem{})).Return(fmt.Errorf("revert")).Once()
-
-		oracle, err := newOpStackL1GasOracle(logger.Test(t), ethClient, chaintype.ChainMantle, oracleAddress)
-		require.NoError(t, err)
-		_, err = oracle.GetDAGasPrice(tests.Context(t))
-		assert.Error(t, err)
-	})
-
-	t.Run("fetching Mantle price but one of the sub rpc call errors", func(t *testing.T) {
-		ethClient := mocks.NewL1OracleClient(t)
-		ethClient.On("BatchCallContext", mock.Anything, mock.IsType([]rpc.BatchElem{})).Run(func(args mock.Arguments) {
-			rpcElements := args.Get(1).([]rpc.BatchElem)
-			res := common.BigToHash(l1BaseFee).Hex()
-			rpcElements[0].Result = &res
-			rpcElements[1].Error = fmt.Errorf("revert")
-		}).Return(nil).Once()
-
-		oracle, err := newOpStackL1GasOracle(logger.Test(t), ethClient, chaintype.ChainMantle, oracleAddress)
-		require.NoError(t, err)
-		_, err = oracle.GetDAGasPrice(tests.Context(t))
-		assert.Error(t, err)
-	})
-}
-
 func setupUpgradeCheck(t *testing.T, oracleAddress string, isFjord, isEcotone bool) *mocks.L1OracleClient {
 	trueHex := "0x0000000000000000000000000000000000000000000000000000000000000001"
 	falseHex := "0x0000000000000000000000000000000000000000000000000000000000000000"
diff --git a/core/chains/evm/gas/rollups/zkSync_l1_oracle.go b/core/chains/evm/gas/rollups/zkSync_l1_oracle.go
index 31d93bc587d..c2941233545 100644
--- a/core/chains/evm/gas/rollups/zkSync_l1_oracle.go
+++ b/core/chains/evm/gas/rollups/zkSync_l1_oracle.go
@@ -83,6 +83,10 @@ func (o *zkSyncL1Oracle) Name() string {
 	return o.logger.Name()
 }
 
+func (o *zkSyncL1Oracle) ChainType(_ context.Context) chaintype.ChainType {
+	return o.chainType
+}
+
 func (o *zkSyncL1Oracle) Start(ctx context.Context) error {
 	return o.StartOnce(o.Name(), func() error {
 		go o.run()
diff --git a/integration-tests/actions/automation_ocr_helpers.go b/integration-tests/actions/automation_ocr_helpers.go
index df9168e25de..f1845804677 100644
--- a/integration-tests/actions/automation_ocr_helpers.go
+++ b/integration-tests/actions/automation_ocr_helpers.go
@@ -2,297 +2,20 @@ package actions
 
 //revive:disable:dot-imports
 import (
-	"encoding/json"
-	"fmt"
 	"math"
 	"math/big"
 	"testing"
-	"time"
 
 	"github.com/pkg/errors"
 
 	"github.com/smartcontractkit/chainlink-testing-framework/seth"
 
-	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/generated/i_automation_registry_master_wrapper_2_3"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/lib/pq"
 	"github.com/stretchr/testify/require"
-	"gopkg.in/guregu/null.v4"
-
-	ocr2 "github.com/smartcontractkit/libocr/offchainreporting2plus/confighelper"
-	ocr3 "github.com/smartcontractkit/libocr/offchainreporting2plus/ocr3confighelper"
-	"github.com/smartcontractkit/libocr/offchainreporting2plus/types"
-
-	ocr2keepers20config "github.com/smartcontractkit/chainlink-automation/pkg/v2/config"
-	ocr2keepers30config "github.com/smartcontractkit/chainlink-automation/pkg/v3/config"
-	"github.com/smartcontractkit/chainlink-testing-framework/lib/logging"
 
-	"github.com/smartcontractkit/chainlink/integration-tests/client"
 	"github.com/smartcontractkit/chainlink/integration-tests/contracts"
 	"github.com/smartcontractkit/chainlink/integration-tests/contracts/ethereum"
-	"github.com/smartcontractkit/chainlink/v2/core/services/job"
-	"github.com/smartcontractkit/chainlink/v2/core/services/keystore/chaintype"
-	"github.com/smartcontractkit/chainlink/v2/core/store/models"
 )
 
-func BuildAutoOCR2ConfigVars(
-	t *testing.T,
-	chainlinkNodes []*client.ChainlinkK8sClient,
-	registryConfig contracts.KeeperRegistrySettings,
-	registrar string,
-	deltaStage time.Duration,
-	chainModuleAddress common.Address,
-	reorgProtectionEnabled bool,
-	linkToken contracts.LinkToken,
-	wethToken contracts.WETHToken,
-	ethUSDFeed contracts.MockETHUSDFeed,
-
-) (contracts.OCRv2Config, error) {
-	return BuildAutoOCR2ConfigVarsWithKeyIndex(t, chainlinkNodes, registryConfig, registrar, deltaStage, 0, common.Address{}, chainModuleAddress, reorgProtectionEnabled, linkToken, wethToken, ethUSDFeed)
-}
-
-func BuildAutoOCR2ConfigVarsWithKeyIndex(
-	t *testing.T,
-	chainlinkNodes []*client.ChainlinkK8sClient,
-	registryConfig contracts.KeeperRegistrySettings,
-	registrar string,
-	deltaStage time.Duration,
-	keyIndex int,
-	registryOwnerAddress common.Address,
-	chainModuleAddress common.Address,
-	reorgProtectionEnabled bool,
-	linkToken contracts.LinkToken,
-	wethToken contracts.WETHToken,
-	ethUSDFeed contracts.MockETHUSDFeed,
-) (contracts.OCRv2Config, error) {
-	l := logging.GetTestLogger(t)
-	S, oracleIdentities, err := GetOracleIdentitiesWithKeyIndex(chainlinkNodes, keyIndex)
-	if err != nil {
-		return contracts.OCRv2Config{}, err
-	}
-
-	var offC []byte
-	var signerOnchainPublicKeys []types.OnchainPublicKey
-	var transmitterAccounts []types.Account
-	var f uint8
-	var offchainConfigVersion uint64
-	var offchainConfig []byte
-
-	if registryConfig.RegistryVersion == ethereum.RegistryVersion_2_1 || registryConfig.RegistryVersion == ethereum.RegistryVersion_2_2 || registryConfig.RegistryVersion == ethereum.RegistryVersion_2_3 {
-		offC, err = json.Marshal(ocr2keepers30config.OffchainConfig{
-			TargetProbability:    "0.999",
-			TargetInRounds:       1,
-			PerformLockoutWindow: 3600000, // Intentionally set to be higher than in prod for testing purpose
-			GasLimitPerReport:    5_300_000,
-			GasOverheadPerUpkeep: 300_000,
-			MinConfirmations:     0,
-			MaxUpkeepBatchSize:   10,
-		})
-		if err != nil {
-			return contracts.OCRv2Config{}, err
-		}
-
-		signerOnchainPublicKeys, transmitterAccounts, f, _, offchainConfigVersion, offchainConfig, err = ocr3.ContractSetConfigArgsForTests(
-			10*time.Second,        // deltaProgress time.Duration,
-			15*time.Second,        // deltaResend time.Duration,
-			500*time.Millisecond,  // deltaInitial time.Duration,
-			1000*time.Millisecond, // deltaRound time.Duration,
-			200*time.Millisecond,  // deltaGrace time.Duration,
-			300*time.Millisecond,  // deltaCertifiedCommitRequest time.Duration
-			deltaStage,            // deltaStage time.Duration,
-			24,                    // rMax uint64,
-			S,                     // s []int,
-			oracleIdentities,      // oracles []OracleIdentityExtra,
-			offC,                  // reportingPluginConfig []byte,
-			20*time.Millisecond,   // maxDurationQuery time.Duration,
-			20*time.Millisecond,   // maxDurationObservation time.Duration, // good to here
-			1200*time.Millisecond, // maxDurationShouldAcceptAttestedReport time.Duration,
-			20*time.Millisecond,   // maxDurationShouldTransmitAcceptedReport time.Duration,
-			1,                     // f int,
-			nil,                   // onchainConfig []byte,
-		)
-		if err != nil {
-			return contracts.OCRv2Config{}, err
-		}
-	} else {
-		offC, err = json.Marshal(ocr2keepers20config.OffchainConfig{
-			TargetProbability:    "0.999",
-			TargetInRounds:       1,
-			PerformLockoutWindow: 3600000, // Intentionally set to be higher than in prod for testing purpose
-			GasLimitPerReport:    5_300_000,
-			GasOverheadPerUpkeep: 300_000,
-			SamplingJobDuration:  3000,
-			MinConfirmations:     0,
-			MaxUpkeepBatchSize:   1,
-		})
-		if err != nil {
-			return contracts.OCRv2Config{}, err
-		}
-
-		signerOnchainPublicKeys, transmitterAccounts, f, _, offchainConfigVersion, offchainConfig, err = ocr2.ContractSetConfigArgsForTests(
-			10*time.Second,        // deltaProgress time.Duration,
-			15*time.Second,        // deltaResend time.Duration,
-			3000*time.Millisecond, // deltaRound time.Duration,
-			200*time.Millisecond,  // deltaGrace time.Duration,
-			deltaStage,            // deltaStage time.Duration,
-			24,                    // rMax uint8,
-			S,                     // s []int,
-			oracleIdentities,      // oracles []OracleIdentityExtra,
-			offC,                  // reportingPluginConfig []byte,
-			20*time.Millisecond,   // maxDurationQuery time.Duration,
-			20*time.Millisecond,   // maxDurationObservation time.Duration,
-			1200*time.Millisecond, // maxDurationReport time.Duration,
-			20*time.Millisecond,   // maxDurationShouldAcceptFinalizedReport time.Duration,
-			20*time.Millisecond,   // maxDurationShouldTransmitAcceptedReport time.Duration,
-			1,                     // f int,
-			nil,                   // onchainConfig []byte,
-		)
-		if err != nil {
-			return contracts.OCRv2Config{}, err
-		}
-	}
-
-	var signers []common.Address
-	for _, signer := range signerOnchainPublicKeys {
-		require.Equal(t, 20, len(signer), "OnChainPublicKey '%v' has wrong length for address", signer)
-		signers = append(signers, common.BytesToAddress(signer))
-	}
-
-	var transmitters []common.Address
-	for _, transmitter := range transmitterAccounts {
-		require.True(t, common.IsHexAddress(string(transmitter)), "TransmitAccount '%s' is not a valid Ethereum address", string(transmitter))
-		transmitters = append(transmitters, common.HexToAddress(string(transmitter)))
-	}
-
-	ocrConfig := contracts.OCRv2Config{
-		Signers:               signers,
-		Transmitters:          transmitters,
-		F:                     f,
-		OffchainConfigVersion: offchainConfigVersion,
-		OffchainConfig:        offchainConfig,
-	}
-
-	if registryConfig.RegistryVersion == ethereum.RegistryVersion_2_0 {
-		ocrConfig.OnchainConfig = registryConfig.Encode20OnchainConfig(registrar)
-	} else if registryConfig.RegistryVersion == ethereum.RegistryVersion_2_1 {
-		ocrConfig.TypedOnchainConfig21 = registryConfig.Create21OnchainConfig(registrar, registryOwnerAddress)
-	} else if registryConfig.RegistryVersion == ethereum.RegistryVersion_2_2 {
-		ocrConfig.TypedOnchainConfig22 = registryConfig.Create22OnchainConfig(registrar, registryOwnerAddress, chainModuleAddress, reorgProtectionEnabled)
-	} else if registryConfig.RegistryVersion == ethereum.RegistryVersion_2_3 {
-		ocrConfig.TypedOnchainConfig23 = registryConfig.Create23OnchainConfig(registrar, registryOwnerAddress, chainModuleAddress, reorgProtectionEnabled)
-		ocrConfig.BillingTokens = []common.Address{
-			common.HexToAddress(linkToken.Address()),
-			common.HexToAddress(wethToken.Address()),
-		}
-
-		ocrConfig.BillingConfigs = []i_automation_registry_master_wrapper_2_3.AutomationRegistryBase23BillingConfig{
-			{
-				GasFeePPB:         100,
-				FlatFeeMilliCents: big.NewInt(500),
-				PriceFeed:         common.HexToAddress(ethUSDFeed.Address()), // ETH/USD feed and LINK/USD feed are the same
-				Decimals:          18,
-				FallbackPrice:     big.NewInt(1000),
-				MinSpend:          big.NewInt(200),
-			},
-			{
-				GasFeePPB:         100,
-				FlatFeeMilliCents: big.NewInt(500),
-				PriceFeed:         common.HexToAddress(ethUSDFeed.Address()), // ETH/USD feed and LINK/USD feed are the same
-				Decimals:          18,
-				FallbackPrice:     big.NewInt(1000),
-				MinSpend:          big.NewInt(200),
-			},
-		}
-	}
-
-	l.Info().Msg("Done building OCR config")
-	return ocrConfig, nil
-}
-
-// CreateOCRKeeperJobs bootstraps the first node and to the other nodes sends ocr jobs
-func CreateOCRKeeperJobs(
-	t *testing.T,
-	chainlinkNodes []*client.ChainlinkK8sClient,
-	registryAddr string,
-	chainID int64,
-	keyIndex int,
-	registryVersion ethereum.KeeperRegistryVersion,
-) {
-	l := logging.GetTestLogger(t)
-	bootstrapNode := chainlinkNodes[0]
-	bootstrapP2PIds, err := bootstrapNode.MustReadP2PKeys()
-	require.NoError(t, err, "Shouldn't fail reading P2P keys from bootstrap node")
-	bootstrapP2PId := bootstrapP2PIds.Data[0].Attributes.PeerID
-
-	var contractVersion string
-	if registryVersion == ethereum.RegistryVersion_2_2 || registryVersion == ethereum.RegistryVersion_2_3 {
-		contractVersion = "v2.1+"
-	} else if registryVersion == ethereum.RegistryVersion_2_1 {
-		contractVersion = "v2.1"
-	} else if registryVersion == ethereum.RegistryVersion_2_0 {
-		contractVersion = "v2.0"
-	} else {
-		require.FailNow(t, fmt.Sprintf("v2.0, v2.1, v2.2 and v2.3 are the only supported versions, but got something else: %v (iota)", registryVersion))
-	}
-
-	bootstrapSpec := &client.OCR2TaskJobSpec{
-		Name:    "ocr2 bootstrap node " + registryAddr,
-		JobType: "bootstrap",
-		OCR2OracleSpec: job.OCR2OracleSpec{
-			ContractID: registryAddr,
-			Relay:      "evm",
-			RelayConfig: map[string]interface{}{
-				"chainID": int(chainID),
-			},
-			ContractConfigTrackerPollInterval: *models.NewInterval(time.Second * 15),
-		},
-	}
-	_, err = bootstrapNode.MustCreateJob(bootstrapSpec)
-	require.NoError(t, err, "Shouldn't fail creating bootstrap job on bootstrap node")
-	// TODO: Use service name returned by chainlink-env once that is available
-	P2Pv2Bootstrapper := fmt.Sprintf("%s@%s-node-1:%d", bootstrapP2PId, bootstrapNode.Name(), 6690)
-
-	for nodeIndex := 1; nodeIndex < len(chainlinkNodes); nodeIndex++ {
-		nodeTransmitterAddress, err := chainlinkNodes[nodeIndex].EthAddresses()
-		require.NoError(t, err, "Shouldn't fail getting primary ETH address from OCR node %d", nodeIndex+1)
-		nodeOCRKeys, err := chainlinkNodes[nodeIndex].MustReadOCR2Keys()
-		require.NoError(t, err, "Shouldn't fail getting OCR keys from OCR node %d", nodeIndex+1)
-		var nodeOCRKeyId []string
-		for _, key := range nodeOCRKeys.Data {
-			if key.Attributes.ChainType == string(chaintype.EVM) {
-				nodeOCRKeyId = append(nodeOCRKeyId, key.ID)
-				break
-			}
-		}
-
-		autoOCR2JobSpec := client.OCR2TaskJobSpec{
-			Name:    "ocr2 " + registryAddr,
-			JobType: "offchainreporting2",
-			OCR2OracleSpec: job.OCR2OracleSpec{
-				PluginType: "ocr2automation",
-				Relay:      "evm",
-				RelayConfig: map[string]interface{}{
-					"chainID": int(chainID),
-				},
-				PluginConfig: map[string]interface{}{
-					"mercuryCredentialName": "\"cred1\"",
-					"contractVersion":       "\"" + contractVersion + "\"",
-				},
-				ContractConfigTrackerPollInterval: *models.NewInterval(time.Second * 15),
-				ContractID:                        registryAddr,                                      // registryAddr
-				OCRKeyBundleID:                    null.StringFrom(nodeOCRKeyId[0]),                  // get node ocr2config.ID
-				TransmitterID:                     null.StringFrom(nodeTransmitterAddress[keyIndex]), // node addr
-				P2PV2Bootstrappers:                pq.StringArray{P2Pv2Bootstrapper},                 // bootstrap node key and address <p2p-key>@bootstrap:8000
-			},
-		}
-
-		_, err = chainlinkNodes[nodeIndex].MustCreateJob(&autoOCR2JobSpec)
-		require.NoError(t, err, "Shouldn't fail creating OCR Task job on OCR node %d err: %+v", nodeIndex+1, err)
-	}
-	l.Info().Msg("Done creating OCR automation jobs")
-}
-
 // DeployAutoOCRRegistryAndRegistrar registry and registrar
 func DeployAutoOCRRegistryAndRegistrar(
 	t *testing.T,
diff --git a/integration-tests/actions/automation_ocr_helpers_local.go b/integration-tests/actions/automation_ocr_helpers_local.go
index d513f1875a4..e4d5ad70cac 100644
--- a/integration-tests/actions/automation_ocr_helpers_local.go
+++ b/integration-tests/actions/automation_ocr_helpers_local.go
@@ -28,7 +28,7 @@ import (
 	"github.com/smartcontractkit/chainlink/v2/core/store/models"
 )
 
-func AutomationDefaultRegistryConfig(c tc.AutomationTestConfig) contracts.KeeperRegistrySettings {
+func ReadRegistryConfig(c tc.AutomationTestConfig) contracts.KeeperRegistrySettings {
 	registrySettings := c.GetAutomationConfig().AutomationConfig.RegistrySettings
 	return contracts.KeeperRegistrySettings{
 		PaymentPremiumPPB:    *registrySettings.PaymentPremiumPPB,
@@ -40,12 +40,49 @@ func AutomationDefaultRegistryConfig(c tc.AutomationTestConfig) contracts.Keeper
 		MaxPerformGas:        *registrySettings.MaxPerformGas,
 		FallbackGasPrice:     registrySettings.FallbackGasPrice,
 		FallbackLinkPrice:    registrySettings.FallbackLinkPrice,
+		FallbackNativePrice:  registrySettings.FallbackNativePrice,
 		MaxCheckDataSize:     *registrySettings.MaxCheckDataSize,
 		MaxPerformDataSize:   *registrySettings.MaxPerformDataSize,
 		MaxRevertDataSize:    *registrySettings.MaxRevertDataSize,
 	}
 }
 
+func ReadPluginConfig(c tc.AutomationTestConfig) ocr2keepers30config.OffchainConfig {
+	plCfg := c.GetAutomationConfig().AutomationConfig.PluginConfig
+	return ocr2keepers30config.OffchainConfig{
+		TargetProbability:    *plCfg.TargetProbability,
+		TargetInRounds:       *plCfg.TargetInRounds,
+		PerformLockoutWindow: *plCfg.PerformLockoutWindow,
+		GasLimitPerReport:    *plCfg.GasLimitPerReport,
+		GasOverheadPerUpkeep: *plCfg.GasOverheadPerUpkeep,
+		MinConfirmations:     *plCfg.MinConfirmations,
+		MaxUpkeepBatchSize:   *plCfg.MaxUpkeepBatchSize,
+		LogProviderConfig: ocr2keepers30config.LogProviderConfig{
+			BlockRate: *plCfg.LogProviderConfig.BlockRate,
+			LogLimit:  *plCfg.LogProviderConfig.LogLimit,
+		},
+	}
+}
+
+func ReadPublicConfig(c tc.AutomationTestConfig) ocr3.PublicConfig {
+	pubCfg := c.GetAutomationConfig().AutomationConfig.PublicConfig
+	return ocr3.PublicConfig{
+		DeltaProgress:                           *pubCfg.DeltaProgress,
+		DeltaResend:                             *pubCfg.DeltaResend,
+		DeltaInitial:                            *pubCfg.DeltaInitial,
+		DeltaRound:                              *pubCfg.DeltaRound,
+		DeltaGrace:                              *pubCfg.DeltaGrace,
+		DeltaCertifiedCommitRequest:             *pubCfg.DeltaCertifiedCommitRequest,
+		DeltaStage:                              *pubCfg.DeltaStage,
+		RMax:                                    *pubCfg.RMax,
+		MaxDurationQuery:                        *pubCfg.MaxDurationQuery,
+		MaxDurationObservation:                  *pubCfg.MaxDurationObservation,
+		MaxDurationShouldAcceptAttestedReport:   *pubCfg.MaxDurationShouldAcceptAttestedReport,
+		MaxDurationShouldTransmitAcceptedReport: *pubCfg.MaxDurationShouldTransmitAcceptedReport,
+		F:                                       *pubCfg.F,
+	}
+}
+
 func BuildAutoOCR2ConfigVarsLocal(
 	l zerolog.Logger,
 	chainlinkNodes []*client.ChainlinkClient,
diff --git a/integration-tests/benchmark/automation_test.go b/integration-tests/benchmark/automation_test.go
index f7e98e6a7a7..534fca2f513 100644
--- a/integration-tests/benchmark/automation_test.go
+++ b/integration-tests/benchmark/automation_test.go
@@ -21,7 +21,6 @@ import (
 	sethutils "github.com/smartcontractkit/chainlink-testing-framework/lib/utils/seth"
 
 	"github.com/smartcontractkit/chainlink/integration-tests/actions"
-	"github.com/smartcontractkit/chainlink/integration-tests/contracts"
 	ethcontracts "github.com/smartcontractkit/chainlink/integration-tests/contracts/ethereum"
 	tc "github.com/smartcontractkit/chainlink/integration-tests/testconfig"
 	"github.com/smartcontractkit/chainlink/integration-tests/testsetups"
@@ -94,25 +93,12 @@ func TestAutomationBenchmark(t *testing.T) {
 	require.NoError(t, err, "Error getting Seth client")
 
 	registryVersions := addRegistry(&config)
+	registrySettings := actions.ReadRegistryConfig(config)
 	keeperBenchmarkTest := testsetups.NewKeeperBenchmarkTest(t,
 		testsetups.KeeperBenchmarkTestInputs{
-			BlockchainClient: chainClient,
-			RegistryVersions: registryVersions,
-			KeeperRegistrySettings: &contracts.KeeperRegistrySettings{
-				PaymentPremiumPPB:    uint32(0),
-				FlatFeeMicroLINK:     uint32(40000),
-				BlockCountPerTurn:    big.NewInt(100),
-				CheckGasLimit:        uint32(45_000_000), //45M
-				StalenessSeconds:     big.NewInt(90_000),
-				GasCeilingMultiplier: uint16(2),
-				MaxPerformGas:        uint32(*config.Automation.Benchmark.MaxPerformGas),
-				MinUpkeepSpend:       big.NewInt(0),
-				FallbackGasPrice:     big.NewInt(2e11),
-				FallbackLinkPrice:    big.NewInt(2e18),
-				MaxCheckDataSize:     uint32(5_000),
-				MaxPerformDataSize:   uint32(5_000),
-				MaxRevertDataSize:    uint32(5_000),
-			},
+			BlockchainClient:       chainClient,
+			RegistryVersions:       registryVersions,
+			KeeperRegistrySettings: &registrySettings,
 			Upkeeps: &testsetups.UpkeepConfig{
 				NumberOfUpkeeps:     *config.Automation.Benchmark.NumberOfUpkeeps,
 				CheckGasToBurn:      *config.Automation.Benchmark.CheckGasToBurn,
diff --git a/integration-tests/chaos/automation_chaos_test.go b/integration-tests/chaos/automation_chaos_test.go
index 59b52f8e0f2..cde5962390a 100644
--- a/integration-tests/chaos/automation_chaos_test.go
+++ b/integration-tests/chaos/automation_chaos_test.go
@@ -6,9 +6,6 @@ import (
 	"testing"
 	"time"
 
-	ocr3 "github.com/smartcontractkit/libocr/offchainreporting2plus/ocr3confighelper"
-
-	ocr2keepers30config "github.com/smartcontractkit/chainlink-automation/pkg/v3/config"
 	"github.com/smartcontractkit/chainlink/integration-tests/actions/automationv2"
 
 	seth_utils "github.com/smartcontractkit/chainlink-testing-framework/lib/utils/seth"
@@ -245,53 +242,15 @@ func TestAutomationChaos(t *testing.T) {
 
 					a := automationv2.NewAutomationTestK8s(l, chainClient, chainlinkNodes)
 					a.SetMercuryCredentialName("cred1")
-					conf := config.Automation.AutomationConfig
-					a.RegistrySettings = contracts.KeeperRegistrySettings{
-						PaymentPremiumPPB:    *conf.RegistrySettings.PaymentPremiumPPB,
-						FlatFeeMicroLINK:     *conf.RegistrySettings.FlatFeeMicroLINK,
-						CheckGasLimit:        *conf.RegistrySettings.CheckGasLimit,
-						StalenessSeconds:     conf.RegistrySettings.StalenessSeconds,
-						GasCeilingMultiplier: *conf.RegistrySettings.GasCeilingMultiplier,
-						MaxPerformGas:        *conf.RegistrySettings.MaxPerformGas,
-						MinUpkeepSpend:       conf.RegistrySettings.MinUpkeepSpend,
-						FallbackGasPrice:     conf.RegistrySettings.FallbackGasPrice,
-						FallbackLinkPrice:    conf.RegistrySettings.FallbackLinkPrice,
-						MaxCheckDataSize:     *conf.RegistrySettings.MaxCheckDataSize,
-						MaxPerformDataSize:   *conf.RegistrySettings.MaxPerformDataSize,
-						MaxRevertDataSize:    *conf.RegistrySettings.MaxRevertDataSize,
-						RegistryVersion:      rv,
-					}
+					a.RegistrySettings = actions.ReadRegistryConfig(config)
+					a.RegistrySettings.RegistryVersion = rv
+					a.PluginConfig = actions.ReadPluginConfig(config)
+					a.PublicConfig = actions.ReadPublicConfig(config)
 					a.RegistrarSettings = contracts.KeeperRegistrarSettings{
 						AutoApproveConfigType: uint8(2),
 						AutoApproveMaxAllowed: 1000,
 						MinLinkJuels:          big.NewInt(0),
 					}
-					plCfg := config.GetAutomationConfig().AutomationConfig.PluginConfig
-					a.PluginConfig = ocr2keepers30config.OffchainConfig{
-						TargetProbability:    *plCfg.TargetProbability,
-						TargetInRounds:       *plCfg.TargetInRounds,
-						PerformLockoutWindow: *plCfg.PerformLockoutWindow,
-						GasLimitPerReport:    *plCfg.GasLimitPerReport,
-						GasOverheadPerUpkeep: *plCfg.GasOverheadPerUpkeep,
-						MinConfirmations:     *plCfg.MinConfirmations,
-						MaxUpkeepBatchSize:   *plCfg.MaxUpkeepBatchSize,
-					}
-					pubCfg := config.GetAutomationConfig().AutomationConfig.PublicConfig
-					a.PublicConfig = ocr3.PublicConfig{
-						DeltaProgress:                           *pubCfg.DeltaProgress,
-						DeltaResend:                             *pubCfg.DeltaResend,
-						DeltaInitial:                            *pubCfg.DeltaInitial,
-						DeltaRound:                              *pubCfg.DeltaRound,
-						DeltaGrace:                              *pubCfg.DeltaGrace,
-						DeltaCertifiedCommitRequest:             *pubCfg.DeltaCertifiedCommitRequest,
-						DeltaStage:                              *pubCfg.DeltaStage,
-						RMax:                                    *pubCfg.RMax,
-						MaxDurationQuery:                        *pubCfg.MaxDurationQuery,
-						MaxDurationObservation:                  *pubCfg.MaxDurationObservation,
-						MaxDurationShouldAcceptAttestedReport:   *pubCfg.MaxDurationShouldAcceptAttestedReport,
-						MaxDurationShouldTransmitAcceptedReport: *pubCfg.MaxDurationShouldTransmitAcceptedReport,
-						F:                                       *pubCfg.F,
-					}
 
 					a.SetupAutomationDeployment(t)
 
diff --git a/integration-tests/contracts/ethereum_keeper_contracts.go b/integration-tests/contracts/ethereum_keeper_contracts.go
index 38aa5c58f0f..90f1af0319b 100644
--- a/integration-tests/contracts/ethereum_keeper_contracts.go
+++ b/integration-tests/contracts/ethereum_keeper_contracts.go
@@ -174,7 +174,7 @@ func (rcs *KeeperRegistrySettings) Create23OnchainConfig(registrar string, regis
 		ChainModule:            chainModuleAddress,
 		ReorgProtectionEnabled: reorgProtectionEnabled,
 		FinanceAdmin:           registryOwnerAddress,
-		FallbackNativePrice:    rcs.FallbackLinkPrice, // Just use the LINK price
+		FallbackNativePrice:    rcs.FallbackNativePrice,
 	}
 }
 
diff --git a/integration-tests/load/automationv2_1/automationv2_1_test.go b/integration-tests/load/automationv2_1/automationv2_1_test.go
index cb2606f00be..6c49d1be44b 100644
--- a/integration-tests/load/automationv2_1/automationv2_1_test.go
+++ b/integration-tests/load/automationv2_1/automationv2_1_test.go
@@ -22,12 +22,8 @@ import (
 	"github.com/slack-go/slack"
 	"github.com/stretchr/testify/require"
 
-	ocr3 "github.com/smartcontractkit/libocr/offchainreporting2plus/ocr3confighelper"
-
 	"github.com/smartcontractkit/chainlink-testing-framework/wasp"
 
-	ocr2keepers30config "github.com/smartcontractkit/chainlink-automation/pkg/v3/config"
-
 	"github.com/smartcontractkit/chainlink-common/pkg/utils/tests"
 	"github.com/smartcontractkit/chainlink-testing-framework/lib/k8s/environment"
 	"github.com/smartcontractkit/chainlink-testing-framework/lib/k8s/pkg/helm/chainlink"
@@ -154,6 +150,7 @@ func setUpDataStreamsWireMock(url string) error {
 func TestLogTrigger(t *testing.T) {
 	ctx := tests.Context(t)
 	l := logging.GetTestLogger(t)
+	registryVersion := contractseth.RegistryVersion_2_1
 
 	loadedTestConfig, err := tc.GetConfig([]string{"Load"}, tc.Automation)
 	if err != nil {
@@ -315,55 +312,15 @@ Load Config:
 	require.NoError(t, err, "Error deploying multicall contract")
 
 	a := automationv2.NewAutomationTestK8s(l, chainClient, chainlinkNodes)
-	conf := loadedTestConfig.Automation.AutomationConfig
-	a.RegistrySettings = contracts.KeeperRegistrySettings{
-		PaymentPremiumPPB:    *conf.RegistrySettings.PaymentPremiumPPB,
-		FlatFeeMicroLINK:     *conf.RegistrySettings.FlatFeeMicroLINK,
-		CheckGasLimit:        *conf.RegistrySettings.CheckGasLimit,
-		StalenessSeconds:     conf.RegistrySettings.StalenessSeconds,
-		GasCeilingMultiplier: *conf.RegistrySettings.GasCeilingMultiplier,
-		MaxPerformGas:        *conf.RegistrySettings.MaxPerformGas,
-		MinUpkeepSpend:       conf.RegistrySettings.MinUpkeepSpend,
-		FallbackGasPrice:     conf.RegistrySettings.FallbackGasPrice,
-		FallbackLinkPrice:    conf.RegistrySettings.FallbackLinkPrice,
-		MaxCheckDataSize:     *conf.RegistrySettings.MaxCheckDataSize,
-		MaxPerformDataSize:   *conf.RegistrySettings.MaxPerformDataSize,
-		MaxRevertDataSize:    *conf.RegistrySettings.MaxRevertDataSize,
-		RegistryVersion:      contractseth.RegistryVersion_2_1,
-	}
+	a.RegistrySettings = actions.ReadRegistryConfig(loadedTestConfig)
+	a.RegistrySettings.RegistryVersion = registryVersion
+	a.PluginConfig = actions.ReadPluginConfig(loadedTestConfig)
+	a.PublicConfig = actions.ReadPublicConfig(loadedTestConfig)
 	a.RegistrarSettings = contracts.KeeperRegistrarSettings{
 		AutoApproveConfigType: uint8(2),
-		AutoApproveMaxAllowed: math.MaxUint16,
+		AutoApproveMaxAllowed: 1000,
 		MinLinkJuels:          big.NewInt(0),
 	}
-	a.PluginConfig = ocr2keepers30config.OffchainConfig{
-		TargetProbability:    *conf.PluginConfig.TargetProbability,
-		TargetInRounds:       *conf.PluginConfig.TargetInRounds,
-		PerformLockoutWindow: *conf.PluginConfig.PerformLockoutWindow,
-		GasLimitPerReport:    *conf.PluginConfig.GasLimitPerReport,
-		GasOverheadPerUpkeep: *conf.PluginConfig.GasOverheadPerUpkeep,
-		MinConfirmations:     *conf.PluginConfig.MinConfirmations,
-		MaxUpkeepBatchSize:   *conf.PluginConfig.MaxUpkeepBatchSize,
-		LogProviderConfig: ocr2keepers30config.LogProviderConfig{
-			BlockRate: *conf.PluginConfig.LogProviderConfig.BlockRate,
-			LogLimit:  *conf.PluginConfig.LogProviderConfig.LogLimit,
-		},
-	}
-	a.PublicConfig = ocr3.PublicConfig{
-		DeltaProgress:                           *conf.PublicConfig.DeltaProgress,
-		DeltaResend:                             *conf.PublicConfig.DeltaResend,
-		DeltaInitial:                            *conf.PublicConfig.DeltaInitial,
-		DeltaRound:                              *conf.PublicConfig.DeltaRound,
-		DeltaGrace:                              *conf.PublicConfig.DeltaGrace,
-		DeltaCertifiedCommitRequest:             *conf.PublicConfig.DeltaCertifiedCommitRequest,
-		DeltaStage:                              *conf.PublicConfig.DeltaStage,
-		RMax:                                    *conf.PublicConfig.RMax,
-		MaxDurationQuery:                        *conf.PublicConfig.MaxDurationQuery,
-		MaxDurationObservation:                  *conf.PublicConfig.MaxDurationObservation,
-		MaxDurationShouldAcceptAttestedReport:   *conf.PublicConfig.MaxDurationShouldAcceptAttestedReport,
-		MaxDurationShouldTransmitAcceptedReport: *conf.PublicConfig.MaxDurationShouldTransmitAcceptedReport,
-		F:                                       *conf.PublicConfig.F,
-	}
 
 	if *loadedTestConfig.Automation.DataStreams.Enabled {
 		a.SetMercuryCredentialName("cred1")
diff --git a/integration-tests/load/go.mod b/integration-tests/load/go.mod
index 1daa663cdcc..673191e145b 100644
--- a/integration-tests/load/go.mod
+++ b/integration-tests/load/go.mod
@@ -15,21 +15,23 @@ require (
 	github.com/pkg/errors v0.9.1
 	github.com/rs/zerolog v1.33.0
 	github.com/slack-go/slack v0.12.2
-	github.com/smartcontractkit/chainlink-automation v1.0.4
 	github.com/smartcontractkit/chainlink-common v0.2.2-0.20240916150342-36cb47701edf
 	github.com/smartcontractkit/chainlink-testing-framework/lib v1.50.5
 	github.com/smartcontractkit/chainlink-testing-framework/seth v1.50.1
 	github.com/smartcontractkit/chainlink-testing-framework/wasp v1.50.0
 	github.com/smartcontractkit/chainlink/integration-tests v0.0.0-20240214231432-4ad5eb95178c
 	github.com/smartcontractkit/chainlink/v2 v2.9.0-beta0.0.20240216210048-da02459ddad8
-	github.com/smartcontractkit/libocr v0.0.0-20240717100443-f6226e09bee7
 	github.com/smartcontractkit/tdh2/go/tdh2 v0.0.0-20230906073235-9e478e5e19f1
 	github.com/stretchr/testify v1.9.0
 	github.com/wiremock/go-wiremock v1.9.0
 	go.uber.org/ratelimit v0.3.0
 )
 
-require github.com/AlekSi/pointer v1.1.0 // indirect
+require (
+	github.com/AlekSi/pointer v1.1.0 // indirect
+	github.com/smartcontractkit/chainlink-automation v1.0.4 // indirect
+	github.com/smartcontractkit/libocr v0.0.0-20240717100443-f6226e09bee7 // indirect
+)
 
 require (
 	contrib.go.opencensus.io/exporter/stackdriver v0.13.5 // indirect
diff --git a/integration-tests/reorg/automation_reorg_test.go b/integration-tests/reorg/automation_reorg_test.go
index 15b3b745827..85ca4b4264a 100644
--- a/integration-tests/reorg/automation_reorg_test.go
+++ b/integration-tests/reorg/automation_reorg_test.go
@@ -10,10 +10,8 @@ import (
 	"strings"
 	"testing"
 
-	ocr3 "github.com/smartcontractkit/libocr/offchainreporting2plus/ocr3confighelper"
 	"go.uber.org/zap/zapcore"
 
-	ocr2keepers30config "github.com/smartcontractkit/chainlink-automation/pkg/v3/config"
 	"github.com/smartcontractkit/chainlink-testing-framework/lib/testreporters"
 	sethUtils "github.com/smartcontractkit/chainlink-testing-framework/lib/utils/seth"
 	"github.com/smartcontractkit/chainlink/integration-tests/actions/automationv2"
@@ -134,43 +132,17 @@ func TestAutomationReorg(t *testing.T) {
 
 			gethRPCClient := ctfClient.NewRPCClient(evmNetwork.HTTPURLs[0], nil)
 
-			registryConfig := actions.AutomationDefaultRegistryConfig(config)
-			registryConfig.RegistryVersion = registryVersion
-
 			a := automationv2.NewAutomationTestDocker(l, sethClient, nodeClients)
 			a.SetMercuryCredentialName("cred1")
-			a.RegistrySettings = registryConfig
+			a.RegistrySettings = actions.ReadRegistryConfig(config)
+			a.RegistrySettings.RegistryVersion = registryVersion
+			a.PluginConfig = actions.ReadPluginConfig(config)
+			a.PublicConfig = actions.ReadPublicConfig(config)
 			a.RegistrarSettings = contracts.KeeperRegistrarSettings{
 				AutoApproveConfigType: uint8(2),
 				AutoApproveMaxAllowed: 1000,
 				MinLinkJuels:          big.NewInt(0),
 			}
-			plCfg := config.GetAutomationConfig().AutomationConfig.PluginConfig
-			a.PluginConfig = ocr2keepers30config.OffchainConfig{
-				TargetProbability:    *plCfg.TargetProbability,
-				TargetInRounds:       *plCfg.TargetInRounds,
-				PerformLockoutWindow: *plCfg.PerformLockoutWindow,
-				GasLimitPerReport:    *plCfg.GasLimitPerReport,
-				GasOverheadPerUpkeep: *plCfg.GasOverheadPerUpkeep,
-				MinConfirmations:     *plCfg.MinConfirmations,
-				MaxUpkeepBatchSize:   *plCfg.MaxUpkeepBatchSize,
-			}
-			pubCfg := config.GetAutomationConfig().AutomationConfig.PublicConfig
-			a.PublicConfig = ocr3.PublicConfig{
-				DeltaProgress:                           *pubCfg.DeltaProgress,
-				DeltaResend:                             *pubCfg.DeltaResend,
-				DeltaInitial:                            *pubCfg.DeltaInitial,
-				DeltaRound:                              *pubCfg.DeltaRound,
-				DeltaGrace:                              *pubCfg.DeltaGrace,
-				DeltaCertifiedCommitRequest:             *pubCfg.DeltaCertifiedCommitRequest,
-				DeltaStage:                              *pubCfg.DeltaStage,
-				RMax:                                    *pubCfg.RMax,
-				MaxDurationQuery:                        *pubCfg.MaxDurationQuery,
-				MaxDurationObservation:                  *pubCfg.MaxDurationObservation,
-				MaxDurationShouldAcceptAttestedReport:   *pubCfg.MaxDurationShouldAcceptAttestedReport,
-				MaxDurationShouldTransmitAcceptedReport: *pubCfg.MaxDurationShouldTransmitAcceptedReport,
-				F:                                       *pubCfg.F,
-			}
 
 			a.SetupAutomationDeployment(t)
 			a.SetDockerEnv(env)
diff --git a/integration-tests/smoke/automation_test.go b/integration-tests/smoke/automation_test.go
index 7844435760d..f5a329a1a29 100644
--- a/integration-tests/smoke/automation_test.go
+++ b/integration-tests/smoke/automation_test.go
@@ -20,9 +20,6 @@ import (
 	"github.com/onsi/gomega"
 	"github.com/stretchr/testify/require"
 
-	ocr3 "github.com/smartcontractkit/libocr/offchainreporting2plus/ocr3confighelper"
-
-	ocr2keepers30config "github.com/smartcontractkit/chainlink-automation/pkg/v3/config"
 	ctfTestEnv "github.com/smartcontractkit/chainlink-testing-framework/lib/docker/test_env"
 	"github.com/smartcontractkit/chainlink-testing-framework/lib/logging"
 	"github.com/smartcontractkit/chainlink-testing-framework/lib/utils/testcontext"
@@ -126,7 +123,7 @@ func SetupAutomationBasic(t *testing.T, nodeUpgrade bool) {
 			isMercury := isMercuryV02 || isMercuryV03
 
 			a := setupAutomationTestDocker(
-				t, registryVersion, actions.AutomationDefaultRegistryConfig(cfg), isMercuryV02, isMercuryV03, &cfg,
+				t, registryVersion, actions.ReadRegistryConfig(cfg), isMercuryV02, isMercuryV03, &cfg,
 			)
 
 			sb, err := a.ChainClient.Client.BlockNumber(context.Background())
@@ -265,7 +262,7 @@ func TestSetUpkeepTriggerConfig(t *testing.T) {
 			require.NoError(t, err, "Failed to get config")
 
 			a := setupAutomationTestDocker(
-				t, registryVersion, actions.AutomationDefaultRegistryConfig(config), false, false, &config,
+				t, registryVersion, actions.ReadRegistryConfig(config), false, false, &config,
 			)
 
 			sb, err := a.ChainClient.Client.BlockNumber(context.Background())
@@ -448,7 +445,7 @@ func TestAutomationAddFunds(t *testing.T) {
 			config, err := tc.GetConfig([]string{"Smoke"}, tc.Automation)
 			require.NoError(t, err, "Failed to get config")
 			a := setupAutomationTestDocker(
-				t, registryVersion, actions.AutomationDefaultRegistryConfig(config), false, false, &config,
+				t, registryVersion, actions.ReadRegistryConfig(config), false, false, &config,
 			)
 
 			sb, err := a.ChainClient.Client.BlockNumber(context.Background())
@@ -528,7 +525,7 @@ func TestAutomationPauseUnPause(t *testing.T) {
 			require.NoError(t, err, "Failed to get config")
 
 			a := setupAutomationTestDocker(
-				t, registryVersion, actions.AutomationDefaultRegistryConfig(config), false, false, &config,
+				t, registryVersion, actions.ReadRegistryConfig(config), false, false, &config,
 			)
 
 			sb, err := a.ChainClient.Client.BlockNumber(context.Background())
@@ -629,7 +626,7 @@ func TestAutomationRegisterUpkeep(t *testing.T) {
 			require.NoError(t, err, "Failed to get config")
 
 			a := setupAutomationTestDocker(
-				t, registryVersion, actions.AutomationDefaultRegistryConfig(config), false, false, &config,
+				t, registryVersion, actions.ReadRegistryConfig(config), false, false, &config,
 			)
 
 			sb, err := a.ChainClient.Client.BlockNumber(context.Background())
@@ -725,7 +722,7 @@ func TestAutomationPauseRegistry(t *testing.T) {
 			require.NoError(t, err, "Failed to get config")
 
 			a := setupAutomationTestDocker(
-				t, registryVersion, actions.AutomationDefaultRegistryConfig(config), false, false, &config,
+				t, registryVersion, actions.ReadRegistryConfig(config), false, false, &config,
 			)
 
 			sb, err := a.ChainClient.Client.BlockNumber(context.Background())
@@ -805,7 +802,7 @@ func TestAutomationKeeperNodesDown(t *testing.T) {
 			require.NoError(t, err, "Failed to get config")
 
 			a := setupAutomationTestDocker(
-				t, registryVersion, actions.AutomationDefaultRegistryConfig(config), false, false, &config,
+				t, registryVersion, actions.ReadRegistryConfig(config), false, false, &config,
 			)
 
 			sb, err := a.ChainClient.Client.BlockNumber(context.Background())
@@ -913,7 +910,7 @@ func TestAutomationPerformSimulation(t *testing.T) {
 			require.NoError(t, err, "Failed to get config")
 
 			a := setupAutomationTestDocker(
-				t, registryVersion, actions.AutomationDefaultRegistryConfig(config), false, false, &config,
+				t, registryVersion, actions.ReadRegistryConfig(config), false, false, &config,
 			)
 
 			sb, err := a.ChainClient.Client.BlockNumber(context.Background())
@@ -984,7 +981,7 @@ func TestAutomationCheckPerformGasLimit(t *testing.T) {
 			config, err := tc.GetConfig([]string{"Smoke"}, tc.Automation)
 			require.NoError(t, err, "Failed to get config")
 			a := setupAutomationTestDocker(
-				t, registryVersion, actions.AutomationDefaultRegistryConfig(config), false, false, &config,
+				t, registryVersion, actions.ReadRegistryConfig(config), false, false, &config,
 			)
 
 			sb, err := a.ChainClient.Client.BlockNumber(context.Background())
@@ -1091,7 +1088,7 @@ func TestAutomationCheckPerformGasLimit(t *testing.T) {
 			}
 
 			// Now increase checkGasLimit on registry
-			highCheckGasLimit := actions.AutomationDefaultRegistryConfig(config)
+			highCheckGasLimit := actions.ReadRegistryConfig(config)
 			highCheckGasLimit.CheckGasLimit = uint32(5000000)
 			highCheckGasLimit.RegistryVersion = registryVersion
 
@@ -1139,7 +1136,7 @@ func TestUpdateCheckData(t *testing.T) {
 			require.NoError(t, err, "Failed to get config")
 
 			a := setupAutomationTestDocker(
-				t, registryVersion, actions.AutomationDefaultRegistryConfig(config), false, false, &config,
+				t, registryVersion, actions.ReadRegistryConfig(config), false, false, &config,
 			)
 
 			sb, err := a.ChainClient.Client.BlockNumber(context.Background())
@@ -1220,7 +1217,7 @@ func TestSetOffchainConfigWithMaxGasPrice(t *testing.T) {
 				t.Fatal(err)
 			}
 			a := setupAutomationTestDocker(
-				t, registryVersion, actions.AutomationDefaultRegistryConfig(config), false, false, &config,
+				t, registryVersion, actions.ReadRegistryConfig(config), false, false, &config,
 			)
 
 			sb, err := a.ChainClient.Client.BlockNumber(context.Background())
@@ -1446,32 +1443,8 @@ func setupAutomationTestDocker(
 		AutoApproveMaxAllowed: 1000,
 		MinLinkJuels:          big.NewInt(0),
 	}
-	plCfg := automationTestConfig.GetAutomationConfig().AutomationConfig.PluginConfig
-	a.PluginConfig = ocr2keepers30config.OffchainConfig{
-		TargetProbability:    *plCfg.TargetProbability,
-		TargetInRounds:       *plCfg.TargetInRounds,
-		PerformLockoutWindow: *plCfg.PerformLockoutWindow,
-		GasLimitPerReport:    *plCfg.GasLimitPerReport,
-		GasOverheadPerUpkeep: *plCfg.GasOverheadPerUpkeep,
-		MinConfirmations:     *plCfg.MinConfirmations,
-		MaxUpkeepBatchSize:   *plCfg.MaxUpkeepBatchSize,
-	}
-	pubCfg := automationTestConfig.GetAutomationConfig().AutomationConfig.PublicConfig
-	a.PublicConfig = ocr3.PublicConfig{
-		DeltaProgress:                           *pubCfg.DeltaProgress,
-		DeltaResend:                             *pubCfg.DeltaResend,
-		DeltaInitial:                            *pubCfg.DeltaInitial,
-		DeltaRound:                              *pubCfg.DeltaRound,
-		DeltaGrace:                              *pubCfg.DeltaGrace,
-		DeltaCertifiedCommitRequest:             *pubCfg.DeltaCertifiedCommitRequest,
-		DeltaStage:                              *pubCfg.DeltaStage,
-		RMax:                                    *pubCfg.RMax,
-		MaxDurationQuery:                        *pubCfg.MaxDurationQuery,
-		MaxDurationObservation:                  *pubCfg.MaxDurationObservation,
-		MaxDurationShouldAcceptAttestedReport:   *pubCfg.MaxDurationShouldAcceptAttestedReport,
-		MaxDurationShouldTransmitAcceptedReport: *pubCfg.MaxDurationShouldTransmitAcceptedReport,
-		F:                                       *pubCfg.F,
-	}
+	a.PluginConfig = actions.ReadPluginConfig(automationTestConfig)
+	a.PublicConfig = actions.ReadPublicConfig(automationTestConfig)
 
 	a.SetupAutomationDeployment(t)
 	a.SetDockerEnv(env)
diff --git a/integration-tests/testconfig/automation/automation.toml b/integration-tests/testconfig/automation/automation.toml
index 5513355eae7..f07136e998e 100644
--- a/integration-tests/testconfig/automation/automation.toml
+++ b/integration-tests/testconfig/automation/automation.toml
@@ -82,6 +82,7 @@ max_perform_gas=5_000_000
 min_upkeep_spend=0
 fallback_gas_price=200_000_000_000
 fallback_link_price=2_000_000_000_000_000_000
+fallback_native_price=2_000_000_000_000_000_000
 max_check_data_size=5_000
 max_perform_data_size=5_000
 max_revert_data_size=5_000
@@ -148,6 +149,7 @@ max_perform_gas=5_000_000
 min_upkeep_spend=0
 fallback_gas_price=200_000_000_000
 fallback_link_price=2_000_000_000_000_000_000
+fallback_native_price=2_000_000_000_000_000_000
 max_check_data_size=5_000
 max_perform_data_size=5_000
 max_revert_data_size=5_000
@@ -199,6 +201,7 @@ max_perform_gas=5_000_000
 min_upkeep_spend=0
 fallback_gas_price=200_000_000_000
 fallback_link_price=2_000_000_000_000_000_000
+fallback_native_price=2_000_000_000_000_000_000
 max_check_data_size=5_000
 max_perform_data_size=5_000
 max_revert_data_size=5_000
@@ -289,6 +292,7 @@ max_perform_gas=5_000_000
 min_upkeep_spend=0
 fallback_gas_price=200_000_000_000
 fallback_link_price=2_000_000_000_000_000_000
+fallback_native_price=2_000_000_000_000_000_000
 max_check_data_size=5_000
 max_perform_data_size=5_000
 max_revert_data_size=5_000
@@ -327,7 +331,6 @@ number_of_upkeeps = 1000
 upkeep_gas_limit = 1500000
 check_gas_to_burn = 10000
 perform_gas_to_burn = 1000
-max_perform_gas = 5000000
 block_range = 3600
 block_interval = 60
 forces_single_tx_key = false
@@ -402,15 +405,16 @@ block_rate=1
 log_limit=2
 
 [Benchmark.Automation.AutomationConfig.RegistrySettings]
-payment_premium_ppb=200_000_000
-flat_fee_micro_link=0
-check_gas_limit=2_500_000
-staleness_seconds=90000
-gas_ceiling_multiplier=1
+payment_premium_ppb=0
+flat_fee_micro_link=40000
+check_gas_limit=45_000_000
+staleness_seconds=90_000
+gas_ceiling_multiplier=2
 max_perform_gas=5_000_000
 min_upkeep_spend=0
 fallback_gas_price=200_000_000_000
 fallback_link_price=2_000_000_000_000_000_000
+fallback_native_price=2_000_000_000_000_000_000
 max_check_data_size=5_000
 max_perform_data_size=5_000
 max_revert_data_size=5_000
@@ -446,7 +450,6 @@ number_of_upkeeps = 50
 upkeep_gas_limit = 1500000
 check_gas_to_burn = 10000
 perform_gas_to_burn = 1000
-max_perform_gas = 5000000
 block_range = 28800
 block_interval = 300
 forces_single_tx_key = false
@@ -530,6 +533,7 @@ max_perform_gas=5_000_000
 min_upkeep_spend=0
 fallback_gas_price=200_000_000_000
 fallback_link_price=2_000_000_000_000_000_000
+fallback_native_price=2_000_000_000_000_000_000
 max_check_data_size=5_000
 max_perform_data_size=5_000
 max_revert_data_size=5_000
diff --git a/integration-tests/testconfig/automation/config.go b/integration-tests/testconfig/automation/config.go
index 96f625a0cf6..2dc68ebf8f8 100644
--- a/integration-tests/testconfig/automation/config.go
+++ b/integration-tests/testconfig/automation/config.go
@@ -61,7 +61,6 @@ type Benchmark struct {
 	UpkeepGasLimit     *int64  `toml:"upkeep_gas_limit"`
 	CheckGasToBurn     *int64  `toml:"check_gas_to_burn"`
 	PerformGasToBurn   *int64  `toml:"perform_gas_to_burn"`
-	MaxPerformGas      *int64  `toml:"max_perform_gas"`
 	BlockRange         *int64  `toml:"block_range"`
 	BlockInterval      *int64  `toml:"block_interval"`
 	ForceSingleTxKey   *bool   `toml:"forces_single_tx_key"`
@@ -87,9 +86,6 @@ func (c *Benchmark) Validate() error {
 	if c.PerformGasToBurn == nil || *c.PerformGasToBurn <= 0 {
 		return errors.New("perform_gas_to_burn must be a positive integer")
 	}
-	if c.MaxPerformGas == nil || *c.MaxPerformGas <= 0 {
-		return errors.New("max_perform_gas must be a positive integer")
-	}
 	if c.BlockRange == nil || *c.BlockRange <= 0 {
 		return errors.New("block_range must be a positive integer")
 	}
@@ -357,6 +353,7 @@ type RegistrySettings struct {
 	MinUpkeepSpend       *big.Int `toml:"min_upkeep_spend"`
 	FallbackGasPrice     *big.Int `toml:"fallback_gas_price"`
 	FallbackLinkPrice    *big.Int `toml:"fallback_link_price"`
+	FallbackNativePrice  *big.Int `toml:"fallback_native_price"`
 	MaxCheckDataSize     *uint32  `toml:"max_check_data_size"`
 	MaxPerformDataSize   *uint32  `toml:"max_perform_data_size"`
 	MaxRevertDataSize    *uint32  `toml:"max_revert_data_size"`
@@ -390,6 +387,9 @@ func (c *RegistrySettings) Validate() error {
 	if c.FallbackLinkPrice == nil || c.FallbackLinkPrice.Cmp(big.NewInt(0)) < 0 {
 		return errors.New("fallback_link_price must be set to a non-negative integer")
 	}
+	if c.FallbackNativePrice == nil || c.FallbackNativePrice.Cmp(big.NewInt(0)) < 0 {
+		return errors.New("fallback_native_price must be set to a non-negative integer")
+	}
 	if c.MaxCheckDataSize == nil || *c.MaxCheckDataSize < 1 {
 		return errors.New("max_check_data_size must be set to a positive integer")
 	}
diff --git a/integration-tests/testsetups/keeper_benchmark.go b/integration-tests/testsetups/keeper_benchmark.go
index a109d027892..40a56ba73c8 100644
--- a/integration-tests/testsetups/keeper_benchmark.go
+++ b/integration-tests/testsetups/keeper_benchmark.go
@@ -12,9 +12,6 @@ import (
 	"testing"
 	"time"
 
-	ocr3 "github.com/smartcontractkit/libocr/offchainreporting2plus/ocr3confighelper"
-
-	ocr2keepers30config "github.com/smartcontractkit/chainlink-automation/pkg/v3/config"
 	"github.com/smartcontractkit/chainlink/integration-tests/actions/automationv2"
 
 	geth "github.com/ethereum/go-ethereum"
@@ -147,8 +144,6 @@ func (k *KeeperBenchmarkTest) Setup(env *environment.Environment, config tt.Auto
 		}
 	}
 
-	conf := config.GetAutomationConfig().AutomationConfig
-
 	for index := range inputs.RegistryVersions {
 		k.log.Info().Int("Index", index).Msg("Starting Test Setup")
 		a := automationv2.NewAutomationTestK8s(k.log, k.chainClient, k.chainlinkNodes)
@@ -159,34 +154,8 @@ func (k *KeeperBenchmarkTest) Setup(env *environment.Environment, config tt.Auto
 			AutoApproveMaxAllowed: math.MaxUint16,
 			MinLinkJuels:          big.NewInt(0),
 		}
-		a.PluginConfig = ocr2keepers30config.OffchainConfig{
-			TargetProbability:    *conf.PluginConfig.TargetProbability,
-			TargetInRounds:       *conf.PluginConfig.TargetInRounds,
-			PerformLockoutWindow: *conf.PluginConfig.PerformLockoutWindow,
-			GasLimitPerReport:    *conf.PluginConfig.GasLimitPerReport,
-			GasOverheadPerUpkeep: *conf.PluginConfig.GasOverheadPerUpkeep,
-			MinConfirmations:     *conf.PluginConfig.MinConfirmations,
-			MaxUpkeepBatchSize:   *conf.PluginConfig.MaxUpkeepBatchSize,
-			LogProviderConfig: ocr2keepers30config.LogProviderConfig{
-				BlockRate: *conf.PluginConfig.LogProviderConfig.BlockRate,
-				LogLimit:  *conf.PluginConfig.LogProviderConfig.LogLimit,
-			},
-		}
-		a.PublicConfig = ocr3.PublicConfig{
-			DeltaProgress:                           *conf.PublicConfig.DeltaProgress,
-			DeltaResend:                             *conf.PublicConfig.DeltaResend,
-			DeltaInitial:                            *conf.PublicConfig.DeltaInitial,
-			DeltaRound:                              *conf.PublicConfig.DeltaRound,
-			DeltaGrace:                              *conf.PublicConfig.DeltaGrace,
-			DeltaCertifiedCommitRequest:             *conf.PublicConfig.DeltaCertifiedCommitRequest,
-			DeltaStage:                              *conf.PublicConfig.DeltaStage,
-			RMax:                                    *conf.PublicConfig.RMax,
-			MaxDurationQuery:                        *conf.PublicConfig.MaxDurationQuery,
-			MaxDurationObservation:                  *conf.PublicConfig.MaxDurationObservation,
-			MaxDurationShouldAcceptAttestedReport:   *conf.PublicConfig.MaxDurationShouldAcceptAttestedReport,
-			MaxDurationShouldTransmitAcceptedReport: *conf.PublicConfig.MaxDurationShouldTransmitAcceptedReport,
-			F:                                       *conf.PublicConfig.F,
-		}
+		a.PluginConfig = actions.ReadPluginConfig(config)
+		a.PublicConfig = actions.ReadPublicConfig(config)
 		a.SetupAutomationDeploymentWithoutJobs(k.t)
 		err = a.SetConfigOnRegistry()
 		require.NoError(k.t, err, "Setting initial config on registry shouldn't fail")
@@ -225,7 +194,6 @@ func (k *KeeperBenchmarkTest) Run() {
 		float64(u.BlockInterval)
 	k.TestReporter.Summary.TestInputs = map[string]interface{}{
 		"NumberOfUpkeeps":     u.NumberOfUpkeeps,
-		"BlockCountPerTurn":   k.Inputs.KeeperRegistrySettings.BlockCountPerTurn,
 		"CheckGasLimit":       k.Inputs.KeeperRegistrySettings.CheckGasLimit,
 		"MaxPerformGas":       k.Inputs.KeeperRegistrySettings.MaxPerformGas,
 		"CheckGasToBurn":      u.CheckGasToBurn,
@@ -249,7 +217,8 @@ func (k *KeeperBenchmarkTest) Run() {
 		}
 		k.automationTests[rIndex].SetTransmitterKeyIndex(txKeyId)
 		k.automationTests[rIndex].AddJobsAndSetConfig(k.t)
-
+		// Give time for OCR nodes to bootstrap
+		time.Sleep(1 * time.Minute)
 	}
 
 	k.log.Info().Msgf("Waiting for %d blocks for all upkeeps to be performed", inputs.Upkeeps.BlockRange+inputs.UpkeepSLA)