Release/2.12.0 ccip1.4

.changeset/popular-stingrays-float.md

@@ -0,0 +1,5 @@
+---
+"ccip": patch
+---
+
+Fix slice bounds out of range error in performBatchCall. #bugfix

.changeset/red-balloons-repeat.md

@@ -0,0 +1,5 @@
+---
+"ccip": patch
+---
+
+Commit NewReportingPlugin retries on error

.changeset/sour-owls-grab.md

@@ -0,0 +1,7 @@
+---
+"chainlink": patch
+---
+
+Added config option `HeadTracker.FinalityTagBypass` to force `HeadTracker` to track blocks up to `FinalityDepth` even if `FinalityTagsEnabled = true`. This option is a temporary measure to address high CPU usage on chains with extremely large actual finality depth (gap between the current head and the latest finalized block). #added
+
+Added config option `HeadTracker.MaxAllowedFinalityDepth` maximum gap between current head to the latest finalized block that `HeadTracker` considers healthy. #added

common/config/chaintype.go

@@ -5,10 +5,8 @@ import (
 	"strings"
 )
 
-// ChainType denotes the chain or network to work with
 type ChainType string
 
-// nolint
 const (
 	ChainArbitrum        ChainType = "arbitrum"
 	ChainCelo            ChainType = "celo"
@@ -18,11 +16,103 @@ const (
 	ChainOptimismBedrock ChainType = "optimismBedrock"
 	ChainScroll          ChainType = "scroll"
 	ChainWeMix           ChainType = "wemix"
-	ChainXDai            ChainType = "xdai" // Deprecated: use ChainGnosis instead
 	ChainXLayer          ChainType = "xlayer"
 	ChainZkSync          ChainType = "zksync"
 )
 
+// IsL2 returns true if this chain is a Layer 2 chain. Notably:
+//   - the block numbers used for log searching are different from calling block.number
+//   - gas bumping is not supported, since there is no tx mempool
+func (c ChainType) IsL2() bool {
+	switch c {
+	case ChainArbitrum, ChainMetis:
+		return true
+	default:
+		return false
+	}
+}
+
+func (c ChainType) IsValid() bool {
+	switch c {
+	case "", ChainArbitrum, ChainCelo, ChainGnosis, ChainKroma, ChainMetis, ChainOptimismBedrock, ChainScroll, ChainWeMix, ChainXLayer, ChainZkSync:
+		return true
+	}
+	return false
+}
+
+func ChainTypeFromSlug(slug string) ChainType {
+	switch slug {
+	case "arbitrum":
+		return ChainArbitrum
+	case "celo":
+		return ChainCelo
+	case "gnosis", "xdai":
+		return ChainGnosis
+	case "kroma":
+		return ChainKroma
+	case "metis":
+		return ChainMetis
+	case "optimismBedrock":
+		return ChainOptimismBedrock
+	case "scroll":
+		return ChainScroll
+	case "wemix":
+		return ChainWeMix
+	case "xlayer":
+		return ChainXLayer
+	case "zksync":
+		return ChainZkSync
+	default:
+		return ChainType(slug)
+	}
+}
+
+type ChainTypeConfig struct {
+	value ChainType
+	slug  string
+}
+
+func NewChainTypeConfig(slug string) *ChainTypeConfig {
+	return &ChainTypeConfig{
+		value: ChainTypeFromSlug(slug),
+		slug:  slug,
+	}
+}
+
+func (c *ChainTypeConfig) MarshalText() ([]byte, error) {
+	if c == nil {
+		return nil, nil
+	}
+	return []byte(c.slug), nil
+}
+
+func (c *ChainTypeConfig) UnmarshalText(b []byte) error {
+	c.slug = string(b)
+	c.value = ChainTypeFromSlug(c.slug)
+	return nil
+}
+
+func (c *ChainTypeConfig) Slug() string {
+	if c == nil {
+		return ""
+	}
+	return c.slug
+}
+
+func (c *ChainTypeConfig) ChainType() ChainType {
+	if c == nil {
+		return ""
+	}
+	return c.value
+}
+
+func (c *ChainTypeConfig) String() string {
+	if c == nil {
+		return ""
+	}
+	return string(c.value)
+}
+
 var ErrInvalidChainType = fmt.Errorf("must be one of %s or omitted", strings.Join([]string{
 	string(ChainArbitrum),
 	string(ChainCelo),
@@ -35,24 +125,3 @@ var ErrInvalidChainType = fmt.Errorf("must be one of %s or omitted", strings.Joi
 	string(ChainXLayer),
 	string(ChainZkSync),
 }, ", "))
-
-// IsValid returns true if the ChainType value is known or empty.
-func (c ChainType) IsValid() bool {
-	switch c {
-	case "", ChainArbitrum, ChainCelo, ChainGnosis, ChainKroma, ChainMetis, ChainOptimismBedrock, ChainScroll, ChainWeMix, ChainXDai, ChainXLayer, ChainZkSync:
-		return true
-	}
-	return false
-}
-
-// IsL2 returns true if this chain is a Layer 2 chain. Notably:
-//   - the block numbers used for log searching are different from calling block.number
-//   - gas bumping is not supported, since there is no tx mempool
-func (c ChainType) IsL2() bool {
-	switch c {
-	case ChainArbitrum, ChainMetis:
-		return true
-	default:
-		return false
-	}
-}

common/headtracker/head_tracker.go

@@ -119,7 +119,7 @@ func (ht *headTracker[HTH, S, ID, BLOCK_HASH]) Start(ctx context.Context) error
 			if ctx.Err() != nil {
 				return ctx.Err()
 			}
-			ht.log.Errorw("Error handling initial head", "err", err)
+			ht.log.Errorw("Error handling initial head", "err", err.Error())
 		}
 
 		ht.wgDone.Add(3)
@@ -337,9 +337,23 @@ func (ht *headTracker[HTH, S, ID, BLOCK_HASH]) backfillLoop() {
 // calculateLatestFinalized - returns latest finalized block. It's expected that currentHeadNumber - is the head of
 // canonical chain. There is no guaranties that returned block belongs to the canonical chain. Additional verification
 // must be performed before usage.
-func (ht *headTracker[HTH, S, ID, BLOCK_HASH]) calculateLatestFinalized(ctx context.Context, currentHead HTH) (h HTH, err error) {
-	if ht.config.FinalityTagEnabled() {
-		return ht.client.LatestFinalizedBlock(ctx)
+func (ht *headTracker[HTH, S, ID, BLOCK_HASH]) calculateLatestFinalized(ctx context.Context, currentHead HTH) (latestFinalized HTH, err error) {
+	if ht.config.FinalityTagEnabled() && !ht.htConfig.FinalityTagBypass() {
+		latestFinalized, err = ht.client.LatestFinalizedBlock(ctx)
+		if err != nil {
+			return latestFinalized, fmt.Errorf("failed to get latest finalized block: %w", err)
+		}
+
+		if !latestFinalized.IsValid() {
+			return latestFinalized, fmt.Errorf("failed to get valid latest finalized block")
+		}
+
+		if currentHead.BlockNumber()-latestFinalized.BlockNumber() > int64(ht.htConfig.MaxAllowedFinalityDepth()) {
+			return latestFinalized, fmt.Errorf("gap between latest finalized block (%d) and current head (%d) is too large (> %d)",
+				latestFinalized.BlockNumber(), currentHead.BlockNumber(), ht.htConfig.MaxAllowedFinalityDepth())
+		}
+
+		return latestFinalized, nil
 	}
 	// no need to make an additional RPC call on chains with instant finality
 	if ht.config.FinalityDepth() == 0 {

common/headtracker/types/config.go

@@ -12,4 +12,6 @@ type HeadTrackerConfig interface {
 	HistoryDepth() uint32
 	MaxBufferSize() uint32
 	SamplingInterval() time.Duration
+	FinalityTagBypass() bool
+	MaxAllowedFinalityDepth() uint32
 }

common/txmgr/txmgr.go

@@ -46,7 +46,8 @@ type TxManager[
 	services.Service
 	Trigger(addr ADDR)
 	CreateTransaction(ctx context.Context, txRequest txmgrtypes.TxRequest[ADDR, TX_HASH]) (etx txmgrtypes.Tx[CHAIN_ID, ADDR, TX_HASH, BLOCK_HASH, SEQ, FEE], err error)
-	GetForwarderForEOA(eoa ADDR) (forwarder ADDR, err error)
+	GetForwarderForEOA(ctx context.Context, eoa ADDR) (forwarder ADDR, err error)
+	GetForwarderForEOAOCR2Feeds(ctx context.Context, eoa, ocr2AggregatorID ADDR) (forwarder ADDR, err error)
 	RegisterResumeCallback(fn ResumeCallback)
 	SendNativeToken(ctx context.Context, chainID CHAIN_ID, from, to ADDR, value big.Int, gasLimit uint64) (etx txmgrtypes.Tx[CHAIN_ID, ADDR, TX_HASH, BLOCK_HASH, SEQ, FEE], err error)
 	Reset(addr ADDR, abandon bool) error
@@ -545,11 +546,20 @@ func (b *Txm[CHAIN_ID, HEAD, ADDR, TX_HASH, BLOCK_HASH, R, SEQ, FEE]) CreateTran
 }
 
 // Calls forwarderMgr to get a proper forwarder for a given EOA.
-func (b *Txm[CHAIN_ID, HEAD, ADDR, TX_HASH, BLOCK_HASH, R, SEQ, FEE]) GetForwarderForEOA(eoa ADDR) (forwarder ADDR, err error) {
+func (b *Txm[CHAIN_ID, HEAD, ADDR, TX_HASH, BLOCK_HASH, R, SEQ, FEE]) GetForwarderForEOA(ctx context.Context, eoa ADDR) (forwarder ADDR, err error) {
 	if !b.txConfig.ForwardersEnabled() {
 		return forwarder, fmt.Errorf("forwarding is not enabled, to enable set Transactions.ForwardersEnabled =true")
 	}
-	forwarder, err = b.fwdMgr.ForwarderFor(eoa)
+	forwarder, err = b.fwdMgr.ForwarderFor(ctx, eoa)
+	return
+}
+
+// GetForwarderForEOAOCR2Feeds calls forwarderMgr to get a proper forwarder for a given EOA and checks if its set as a transmitter on the OCR2Aggregator contract.
+func (b *Txm[CHAIN_ID, HEAD, ADDR, TX_HASH, BLOCK_HASH, R, SEQ, FEE]) GetForwarderForEOAOCR2Feeds(ctx context.Context, eoa, ocr2Aggregator ADDR) (forwarder ADDR, err error) {
+	if !b.txConfig.ForwardersEnabled() {
+		return forwarder, fmt.Errorf("forwarding is not enabled, to enable set Transactions.ForwardersEnabled =true")
+	}
+	forwarder, err = b.fwdMgr.ForwarderForOCR2Feeds(ctx, eoa, ocr2Aggregator)
 	return
 }
 
@@ -646,9 +656,13 @@ func (n *NullTxManager[CHAIN_ID, HEAD, ADDR, TX_HASH, BLOCK_HASH, SEQ, FEE]) Tri
 func (n *NullTxManager[CHAIN_ID, HEAD, ADDR, TX_HASH, BLOCK_HASH, SEQ, FEE]) CreateTransaction(ctx context.Context, txRequest txmgrtypes.TxRequest[ADDR, TX_HASH]) (etx txmgrtypes.Tx[CHAIN_ID, ADDR, TX_HASH, BLOCK_HASH, SEQ, FEE], err error) {
 	return etx, errors.New(n.ErrMsg)
 }
-func (n *NullTxManager[CHAIN_ID, HEAD, ADDR, TX_HASH, BLOCK_HASH, SEQ, FEE]) GetForwarderForEOA(addr ADDR) (fwdr ADDR, err error) {
+func (n *NullTxManager[CHAIN_ID, HEAD, ADDR, TX_HASH, BLOCK_HASH, SEQ, FEE]) GetForwarderForEOA(ctx context.Context, addr ADDR) (fwdr ADDR, err error) {
+	return fwdr, err
+}
+func (n *NullTxManager[CHAIN_ID, HEAD, ADDR, TX_HASH, BLOCK_HASH, SEQ, FEE]) GetForwarderForEOAOCR2Feeds(ctx context.Context, _, _ ADDR) (fwdr ADDR, err error) {
 	return fwdr, err
 }
+
 func (n *NullTxManager[CHAIN_ID, HEAD, ADDR, TX_HASH, BLOCK_HASH, SEQ, FEE]) Reset(addr ADDR, abandon bool) error {
 	return nil
 }

common/txmgr/types/forwarder_manager.go

@@ -1,14 +1,18 @@
 package types
 
 import (
+	"context"
+
 	"github.com/smartcontractkit/chainlink-common/pkg/services"
+
 	"github.com/smartcontractkit/chainlink/v2/common/types"
 )
 
 //go:generate mockery --quiet --name ForwarderManager --output ./mocks/ --case=underscore
 type ForwarderManager[ADDR types.Hashable] interface {
 	services.Service
-	ForwarderFor(addr ADDR) (forwarder ADDR, err error)
+	ForwarderFor(ctx context.Context, addr ADDR) (forwarder ADDR, err error)
+	ForwarderForOCR2Feeds(ctx context.Context, eoa, ocr2Aggregator ADDR) (forwarder ADDR, err error)
 	// Converts payload to be forwarder-friendly
 	ConvertPayload(dest ADDR, origPayload []byte) ([]byte, error)
 }