add perform data size check

core/cmd/local_client_test.go

@@ -150,6 +150,7 @@ KEEPER_BASE_FEE_BUFFER_PERCENT: 20
 KEEPER_MAXIMUM_GRACE_PERIOD: 100
 KEEPER_REGISTRY_CHECK_GAS_OVERHEAD: 200000
 KEEPER_REGISTRY_PERFORM_GAS_OVERHEAD: 150000
+KEEPER_REGISTRY_MAX_PERFORM_DATA_SIZE: 5000
 KEEPER_REGISTRY_SYNC_INTERVAL: 30m0s
 KEEPER_REGISTRY_SYNC_UPKEEP_QUEUE_SIZE: 10
 KEEPER_CHECK_UPKEEP_GAS_PRICE_FEATURE_ENABLED: false

core/config/envvar/envvar.go

@@ -28,6 +28,7 @@ var (
 	JobPipelineReaperThreshold        = NewDuration("JobPipelineReaperThreshold")
 	KeeperRegistryCheckGasOverhead    = NewUint32("KeeperRegistryCheckGasOverhead")
 	KeeperRegistryPerformGasOverhead  = NewUint32("KeeperRegistryPerformGasOverhead")
+	KeeperRegistryMaxPerformDataSize  = NewUint32("KeeperRegistryMaxPerformDataSize")
 	KeeperRegistrySyncInterval        = NewDuration("KeeperRegistrySyncInterval")
 	KeeperRegistrySyncUpkeepQueueSize = NewUint32("KeeperRegistrySyncUpkeepQueueSize")
 	LogLevel                          = New[zapcore.Level]("LogLevel", parse.LogLevel)

core/config/envvar/schema.go

@@ -281,6 +281,7 @@ type ConfigSchema struct {
 	KeeperMaximumGracePeriod                int64         `env:"KEEPER_MAXIMUM_GRACE_PERIOD" default:"100"`
 	KeeperRegistryCheckGasOverhead          uint64        `env:"KEEPER_REGISTRY_CHECK_GAS_OVERHEAD" default:"200000"`
 	KeeperRegistryPerformGasOverhead        uint64        `env:"KEEPER_REGISTRY_PERFORM_GAS_OVERHEAD" default:"150000"`
+	KeeperRegistryMaxPerformDataSize        uint64        `env:"KEEPER_REGISTRY_MAX_PERFORM_DATA_SIZE" default:"5000"`
 	KeeperRegistrySyncInterval              time.Duration `env:"KEEPER_REGISTRY_SYNC_INTERVAL" default:"30m"`
 	KeeperRegistrySyncUpkeepQueueSize       uint32        `env:"KEEPER_REGISTRY_SYNC_UPKEEP_QUEUE_SIZE" default:"10"`
 	KeeperTurnLookBack                      int64         `env:"KEEPER_TURN_LOOK_BACK" default:"1000"`

core/config/envvar/schema_test.go

@@ -126,6 +126,7 @@ func TestConfigSchema(t *testing.T) {
 		"KeeperMaximumGracePeriod":                       "KEEPER_MAXIMUM_GRACE_PERIOD",
 		"KeeperRegistryCheckGasOverhead":                 "KEEPER_REGISTRY_CHECK_GAS_OVERHEAD",
 		"KeeperRegistryPerformGasOverhead":               "KEEPER_REGISTRY_PERFORM_GAS_OVERHEAD",
+		"KeeperRegistryMaxPerformDataSize":               "KEEPER_REGISTRY_MAX_PERFORM_DATA_SIZE",
 		"KeeperRegistrySyncInterval":                     "KEEPER_REGISTRY_SYNC_INTERVAL",
 		"KeeperRegistrySyncUpkeepQueueSize":              "KEEPER_REGISTRY_SYNC_UPKEEP_QUEUE_SIZE",
 		"KeeperTurnLookBack":                             "KEEPER_TURN_LOOK_BACK",

core/config/general_config.go

@@ -131,6 +131,7 @@ type GeneralOnlyConfig interface {
 	KeeperMaximumGracePeriod() int64
 	KeeperRegistryCheckGasOverhead() uint32
 	KeeperRegistryPerformGasOverhead() uint32
+	KeeperRegistryMaxPerformDataSize() uint32
 	KeeperRegistrySyncInterval() time.Duration
 	KeeperRegistrySyncUpkeepQueueSize() uint32
 	KeeperTurnLookBack() int64
@@ -847,6 +848,12 @@ func (c *generalConfig) KeeperRegistryPerformGasOverhead() uint32 {
 	return getEnvWithFallback(c, envvar.KeeperRegistryPerformGasOverhead)
 }
 
+// KeeperRegistryMaxPerformDataSize is the max perform data size we allow in our pipeline for an
+// upkeep to be performed with
+func (c *generalConfig) KeeperRegistryMaxPerformDataSize() uint32 {
+	return getEnvWithFallback(c, envvar.KeeperRegistryMaxPerformDataSize)
+}
+
 // KeeperDefaultTransactionQueueDepth controls the queue size for DropOldestStrategy in Keeper
 // Set to 0 to use SendEvery strategy instead
 func (c *generalConfig) KeeperDefaultTransactionQueueDepth() uint32 {

core/config/presenters.go

@@ -66,6 +66,7 @@ type EnvPrinter struct {
 	KeeperMaximumGracePeriod                   int64           `json:"KEEPER_MAXIMUM_GRACE_PERIOD"`
 	KeeperRegistryCheckGasOverhead             uint32          `json:"KEEPER_REGISTRY_CHECK_GAS_OVERHEAD"`
 	KeeperRegistryPerformGasOverhead           uint32          `json:"KEEPER_REGISTRY_PERFORM_GAS_OVERHEAD"`
+	KeeperRegistryMaxPerformDataSize           uint32          `json:"KEEPER_REGISTRY_MAX_PERFORM_DATA_SIZE"`
 	KeeperRegistrySyncInterval                 time.Duration   `json:"KEEPER_REGISTRY_SYNC_INTERVAL"`
 	KeeperRegistrySyncUpkeepQueueSize          uint32          `json:"KEEPER_REGISTRY_SYNC_UPKEEP_QUEUE_SIZE"`
 	KeeperCheckUpkeepGasPriceFeatureEnabled    bool            `json:"KEEPER_CHECK_UPKEEP_GAS_PRICE_FEATURE_ENABLED"`
@@ -181,6 +182,7 @@ func NewConfigPrinter(cfg GeneralConfig) ConfigPrinter {
 			KeeperMaximumGracePeriod:                cfg.KeeperMaximumGracePeriod(),
 			KeeperRegistryCheckGasOverhead:          cfg.KeeperRegistryCheckGasOverhead(),
 			KeeperRegistryPerformGasOverhead:        cfg.KeeperRegistryPerformGasOverhead(),
+			KeeperRegistryMaxPerformDataSize:        cfg.KeeperRegistryMaxPerformDataSize(),
 			KeeperRegistrySyncInterval:              cfg.KeeperRegistrySyncInterval(),
 			KeeperRegistrySyncUpkeepQueueSize:       cfg.KeeperRegistrySyncUpkeepQueueSize(),
 			KeeperCheckUpkeepGasPriceFeatureEnabled: cfg.KeeperCheckUpkeepGasPriceFeatureEnabled(),

core/config/v2/types.go

@@ -307,6 +307,7 @@ type Keeper struct {
 	MaximumGracePeriod           *int64
 	RegistryCheckGasOverhead     *uint32
 	RegistryPerformGasOverhead   *uint32
+	RegistryMaxPerformDataSize   *uint32
 	RegistrySyncInterval         *models.Duration
 	RegistrySyncUpkeepQueueSize  *uint32
 	TurnLookBack                 *int64

core/internal/testutils/configtest/general_config.go

@@ -89,6 +89,7 @@ type GeneralConfigOverrides struct {
 	GlobalMinimumContractPayment            *assets.Link
 	GlobalOCRObservationGracePeriod         time.Duration
 	KeeperCheckUpkeepGasPriceFeatureEnabled null.Bool
+	KeeperRegistryMaxPerformDataSize        null.Int
 	KeeperMaximumGracePeriod                null.Int
 	KeeperRegistrySyncInterval              *time.Duration
 	KeeperRegistrySyncUpkeepQueueSize       null.Int
@@ -443,6 +444,13 @@ func (c *TestGeneralConfig) KeeperRegistrySyncUpkeepQueueSize() uint32 {
 	return c.GeneralConfig.KeeperRegistrySyncUpkeepQueueSize()
 }
 
+func (c *TestGeneralConfig) KeeperRegistryMaxPerformDataSize() uint32 {
+	if c.Overrides.KeeperRegistryMaxPerformDataSize.Valid {
+		return uint32(c.Overrides.KeeperRegistryMaxPerformDataSize.Int64)
+	}
+	return c.GeneralConfig.KeeperRegistryMaxPerformDataSize()
+}
+
 // KeeperCheckUpkeepGasPriceFeatureEnabled overrides
 func (c *TestGeneralConfig) KeeperCheckUpkeepGasPriceFeatureEnabled() bool {
 	if c.Overrides.KeeperCheckUpkeepGasPriceFeatureEnabled.Valid {

core/services/chainlink/config_dump.go

@@ -883,6 +883,7 @@ func (c *Config) loadLegacyCoreEnv() {
 		MaximumGracePeriod:           envvar.NewInt64("KeeperMaximumGracePeriod").ParsePtr(),
 		RegistryCheckGasOverhead:     envvar.NewUint32("KeeperRegistryCheckGasOverhead").ParsePtr(),
 		RegistryPerformGasOverhead:   envvar.NewUint32("KeeperRegistryPerformGasOverhead").ParsePtr(),
+		RegistryMaxPerformDataSize:   envvar.NewUint32("KeeperRegistryMaxPerformDataSize").ParsePtr(),
 		RegistrySyncInterval:         envDuration("KeeperRegistrySyncInterval"),
 		RegistrySyncUpkeepQueueSize:  envvar.KeeperRegistrySyncUpkeepQueueSize.ParsePtr(),
 		TurnLookBack:                 envvar.NewInt64("KeeperTurnLookBack").ParsePtr(),

core/services/chainlink/config_general.go

@@ -357,6 +357,10 @@ func (g *generalConfig) KeeperRegistryPerformGasOverhead() uint32 {
 	return *g.c.Keeper.RegistryPerformGasOverhead
 }
 
+func (g *generalConfig) KeeperRegistryMaxPerformDataSize() uint32 {
+	return *g.c.Keeper.RegistryMaxPerformDataSize
+}
+
 func (g *generalConfig) KeeperRegistrySyncInterval() time.Duration {
 	return g.c.Keeper.RegistrySyncInterval.Duration()
 }

core/services/chainlink/config_test.go

@@ -351,6 +351,7 @@ func TestConfig_Marshal(t *testing.T) {
 		RegistryPerformGasOverhead:   ptr[uint32](math.MaxUint32),
 		RegistrySyncInterval:         models.MustNewDuration(time.Hour),
 		RegistrySyncUpkeepQueueSize:  ptr[uint32](31),
+		RegistryMaxPerformDataSize:   ptr[uint32](5000),
 		TurnLookBack:                 ptr[int64](91),
 		TurnFlagEnabled:              ptr(true),
 		UpkeepCheckGasPriceEnabled:   ptr(true),
@@ -710,6 +711,7 @@ BaseFeeBufferPercent = 89
 MaximumGracePeriod = 31
 RegistryCheckGasOverhead = 90
 RegistryPerformGasOverhead = 4294967295
+RegistryMaxPerformDataSize = 5000
 RegistrySyncInterval = '1h0m0s'
 RegistrySyncUpkeepQueueSize = 31
 TurnLookBack = 91

core/services/chainlink/testdata/config-full.toml

@@ -144,6 +144,7 @@ BaseFeeBufferPercent = 89
 MaximumGracePeriod = 31
 RegistryCheckGasOverhead = 90
 RegistryPerformGasOverhead = 4294967295
+RegistryMaxPerformDataSize = 5000
 RegistrySyncInterval = '1h0m0s'
 RegistrySyncUpkeepQueueSize = 31
 TurnLookBack = 91

core/services/chainlink/testdata/dump/empty-strings.env

@@ -215,6 +215,7 @@ KEEPER_BASE_FEE_BUFFER_PERCENT=
 KEEPER_MAXIMUM_GRACE_PERIOD=
 KEEPER_REGISTRY_CHECK_GAS_OVERHEAD=
 KEEPER_REGISTRY_PERFORM_GAS_OVERHEAD=
+KEEPER_REGISTRY_MAX_PERFORM_DATA_SIZE=
 KEEPER_REGISTRY_SYNC_INTERVAL=
 KEEPER_REGISTRY_SYNC_UPKEEP_QUEUE_SIZE=
 KEEPER_TURN_LOOK_BACK=

core/services/chainlink/testdata/dump/full-custom.env

@@ -211,6 +211,7 @@ KEEPER_BASE_FEE_BUFFER_PERCENT=7
 KEEPER_MAXIMUM_GRACE_PERIOD=42
 KEEPER_REGISTRY_CHECK_GAS_OVERHEAD=6
 KEEPER_REGISTRY_PERFORM_GAS_OVERHEAD=900
+KEEPER_REGISTRY_MAX_PERFORM_DATA_SIZE=5000
 KEEPER_REGISTRY_SYNC_INTERVAL=1m
 KEEPER_REGISTRY_SYNC_UPKEEP_QUEUE_SIZE=99
 KEEPER_TURN_LOOK_BACK=67

core/services/chainlink/testdata/dump/full-custom.toml

@@ -140,6 +140,7 @@ BaseFeeBufferPercent = 7
 MaximumGracePeriod = 42
 RegistryCheckGasOverhead = 6
 RegistryPerformGasOverhead = 900
+RegistryMaxPerformDataSize = 5000
 RegistrySyncInterval = '1m0s'
 RegistrySyncUpkeepQueueSize = 99
 TurnLookBack = 67

core/services/chainlink/testdata/dump/none-valid.env

@@ -111,6 +111,7 @@ KEEPER_BASE_FEE_BUFFER_PERCENT=invalid-test-value-KEEPER_BASE_FEE_BUFFER_PERCENT
 KEEPER_MAXIMUM_GRACE_PERIOD=invalid-test-value-KEEPER_MAXIMUM_GRACE_PERIOD
 KEEPER_REGISTRY_CHECK_GAS_OVERHEAD=invalid-test-value-KEEPER_REGISTRY_CHECK_GAS_OVERHEAD
 KEEPER_REGISTRY_PERFORM_GAS_OVERHEAD=invalid-test-value-KEEPER_REGISTRY_PERFORM_GAS_OVERHEAD
+KEEPER_REGISTRY_MAX_PERFORM_DATA_SIZE=invalid-test-value-KEEPER_REGISTRY_MAX_PERFORM_DATA_SIZE
 KEEPER_REGISTRY_SYNC_INTERVAL=invalid-test-value-KEEPER_REGISTRY_SYNC_INTERVAL
 KEEPER_REGISTRY_SYNC_UPKEEP_QUEUE_SIZE=invalid-test-value-KEEPER_REGISTRY_SYNC_UPKEEP_QUEUE_SIZE
 KEEPER_TURN_LOOK_BACK=invalid-test-value-KEEPER_TURN_LOOK_BACK

core/services/keeper/common.go

@@ -26,6 +26,7 @@ type Config interface {
 	KeeperMaximumGracePeriod() int64
 	KeeperRegistryCheckGasOverhead() uint32
 	KeeperRegistryPerformGasOverhead() uint32
+	KeeperRegistryMaxPerformDataSize() uint32
 	KeeperRegistrySyncInterval() time.Duration
 	KeeperRegistrySyncUpkeepQueueSize() uint32
 	KeeperCheckUpkeepGasPriceFeatureEnabled() bool
@@ -37,4 +38,5 @@ type Config interface {
 type RegistryGasChecker interface {
 	KeeperRegistryCheckGasOverhead() uint32
 	KeeperRegistryPerformGasOverhead() uint32
+	KeeperRegistryMaxPerformDataSize() uint32
 }

core/services/keeper/integration_test.go

@@ -320,3 +320,116 @@ func TestKeeperEthIntegration(t *testing.T) {
 		})
 	}
 }
+
+func TestMaxPerformDataSize(t *testing.T) {
+	t.Run("max_perform_data_size_test", func(t *testing.T) {
+		maxPerformDataSize := 1000 // Will be set as config override
+		g := gomega.NewWithT(t)
+
+		// setup node key
+		nodeKey := cltest.MustGenerateRandomKey(t)
+		nodeAddress := nodeKey.Address
+		nodeAddressEIP55 := ethkey.EIP55AddressFromAddress(nodeAddress)
+
+		// setup blockchain
+		sergey := testutils.MustNewSimTransactor(t) // owns all the link
+		steve := testutils.MustNewSimTransactor(t)  // registry owner
+		carrol := testutils.MustNewSimTransactor(t) // client
+		nelly := testutils.MustNewSimTransactor(t)  // other keeper operator 1
+		nick := testutils.MustNewSimTransactor(t)   // other keeper operator 2
+		genesisData := core.GenesisAlloc{
+			sergey.From: {Balance: assets.Ether(1000)},
+			steve.From:  {Balance: assets.Ether(1000)},
+			carrol.From: {Balance: assets.Ether(1000)},
+			nelly.From:  {Balance: assets.Ether(1000)},
+			nick.From:   {Balance: assets.Ether(1000)},
+			nodeAddress: {Balance: assets.Ether(1000)},
+		}
+
+		gasLimit := uint32(ethconfig.Defaults.Miner.GasCeil * 2)
+		backend := cltest.NewSimulatedBackend(t, genesisData, gasLimit)
+
+		stopMining := cltest.Mine(backend, 1*time.Second) // >> 2 seconds and the test gets slow, << 1 second and the app may miss heads
+		defer stopMining()
+
+		linkAddr, _, linkToken, err := link_token_interface.DeployLinkToken(sergey, backend)
+		require.NoError(t, err)
+		gasFeedAddr, _, _, err := mock_v3_aggregator_contract.DeployMockV3AggregatorContract(steve, backend, 18, big.NewInt(60000000000))
+		require.NoError(t, err)
+		linkFeedAddr, _, _, err := mock_v3_aggregator_contract.DeployMockV3AggregatorContract(steve, backend, 18, big.NewInt(20000000000000000))
+		require.NoError(t, err)
+
+		regAddr, registryWrapper := deployKeeperRegistry(t, keeper.RegistryVersion_1_3, steve, backend, linkAddr, linkFeedAddr, gasFeedAddr)
+
+		upkeepAddr, _, upkeepContract, err := basic_upkeep_contract.DeployBasicUpkeepContract(carrol, backend)
+		require.NoError(t, err)
+		_, err = linkToken.Transfer(sergey, carrol.From, oneHunEth)
+		require.NoError(t, err)
+		_, err = linkToken.Approve(carrol, regAddr, oneHunEth)
+		require.NoError(t, err)
+		_, err = registryWrapper.SetKeepers(steve, []common.Address{nodeAddress, nelly.From}, []common.Address{nodeAddress, nelly.From})
+		require.NoError(t, err)
+		registrationTx, err := registryWrapper.RegisterUpkeep(steve, upkeepAddr, 2_500_000, carrol.From, []byte{})
+		require.NoError(t, err)
+		backend.Commit()
+		upkeepID := getUpkeepIdFromTx(t, registryWrapper, registrationTx, backend)
+
+		_, err = registryWrapper.AddFunds(carrol, upkeepID, tenEth)
+		require.NoError(t, err)
+		backend.Commit()
+
+		// setup app
+		config, db := heavyweight.FullTestDB(t, fmt.Sprintf("keeper_max_perform_data_test"))
+		korm := keeper.NewORM(db, logger.TestLogger(t), nil, nil)
+		d := 24 * time.Hour
+		// disable full sync ticker for test
+		config.Overrides.KeeperRegistrySyncInterval = &d
+		// backfill will trigger sync on startup
+		config.Overrides.BlockBackfillDepth = null.IntFrom(0)
+		// disable reorg protection for this test
+		config.Overrides.GlobalMinIncomingConfirmations = null.IntFrom(1)
+		// avoid waiting to re-submit for upkeeps
+		config.Overrides.KeeperMaximumGracePeriod = null.IntFrom(0)
+		// test with gas price feature enabled
+		config.Overrides.KeeperCheckUpkeepGasPriceFeatureEnabled = null.BoolFrom(true)
+		// testing doesn't need to do far look back
+		config.Overrides.KeeperTurnLookBack = null.IntFrom(0)
+		// testing new turn taking
+		config.Overrides.KeeperTurnFlagEnabled = null.BoolFrom(true)
+		// helps prevent missed heads
+		config.Overrides.GlobalEvmHeadTrackerMaxBufferSize = null.IntFrom(100)
+		// set the max perform data size
+		config.Overrides.KeeperRegistryMaxPerformDataSize = null.IntFrom(int64(maxPerformDataSize))
+
+		app := cltest.NewApplicationWithConfigAndKeyOnSimulatedBlockchain(t, config, backend, nodeKey)
+		require.NoError(t, app.Start(testutils.Context(t)))
+
+		// create job
+		regAddrEIP55 := ethkey.EIP55AddressFromAddress(regAddr)
+		job := cltest.MustInsertKeeperJob(t, db, korm, nodeAddressEIP55, regAddrEIP55)
+		err = app.JobSpawner().StartService(testutils.Context(t), job)
+		require.NoError(t, err)
+
+		// keeper job is triggered
+		receivedBytes := func() []byte {
+			received, err2 := upkeepContract.ReceivedBytes(nil)
+			require.NoError(t, err2)
+			return received
+		}
+
+		hugePayload := make([]byte, maxPerformDataSize)
+		_, err = upkeepContract.SetBytesToSend(carrol, hugePayload)
+		require.NoError(t, err)
+		_, err = upkeepContract.SetShouldPerformUpkeep(carrol, true)
+		require.NoError(t, err)
+
+		// Huge payload should not result in a perform
+		g.Consistently(receivedBytes, 20*time.Second, cltest.DBPollingInterval).Should(gomega.Equal([]byte{}))
+
+		// Set payload to be small and it should get received
+		smallPayload := make([]byte, maxPerformDataSize-1)
+		_, err = upkeepContract.SetBytesToSend(carrol, smallPayload)
+		require.NoError(t, err)
+		g.Eventually(receivedBytes, 20*time.Second, cltest.DBPollingInterval).Should(gomega.Equal(smallPayload))
+	})
+}

core/services/keeper/upkeep_executer.go

@@ -322,6 +322,7 @@ func buildJobSpec(
 			"upkeepID":              upkeep.UpkeepID.String(),
 			"prettyID":              upkeep.PrettyID(),
 			"performUpkeepGasLimit": upkeep.ExecuteGas + ormConfig.KeeperRegistryPerformGasOverhead(),
+			"maxPerformDataSize":    ormConfig.KeeperRegistryMaxPerformDataSize(),
 			"gasPrice":              gasPrice,
 			"gasTipCap":             gasTipCap,
 			"gasFeeCap":             gasFeeCap,