CCIP-4703: Adding check for ChainFeeUpdates field

commit/chainfee/validate_observation.go

@@ -21,32 +21,74 @@ func (p *processor) ValidateObservation(
 		return fmt.Errorf("failed to validate FChain: %w", err)
 	}
 
-	observerSupportedChains, err := p.chainSupport.SupportedChains(ao.OracleID)
-	if err != nil {
-		return fmt.Errorf("failed to get supported chains: %w", err)
+	if err := p.ValidateObservedChains(ao); err != nil {
+		return fmt.Errorf("failed to validate observed chains: %w", err)
 	}
 
-	observedChains := append(maps.Keys(obs.FeeComponents), maps.Keys(obs.NativeTokenPrices)...)
+	if err := validateFeeComponents(ao); err != nil {
+		return fmt.Errorf("failed to validate fee components: %w", err)
+	}
 
-	for _, chain := range observedChains {
-		if !observerSupportedChains.Contains(chain) {
-			return fmt.Errorf("chain %d is not supported by observer", chain)
+	if err := validateChainFeeUpdates(ao); err != nil {
+		return fmt.Errorf("failed to validate chain fee updates: %w", err)
+	}
+
+	for _, token := range obs.NativeTokenPrices {
+		if token.Int == nil || token.Int.Cmp(zero) <= 0 {
+			return fmt.Errorf("nil or non-positive %s", "execution fee")
 		}
 	}
 
-	for _, feeComponent := range obs.FeeComponents {
-		if feeComponent.ExecutionFee == nil || feeComponent.ExecutionFee.Cmp(zero) <= 0 {
+	return nil
+}
+
+func validateChainFeeUpdates(
+	ao plugincommon.AttributedObservation[Observation],
+) error {
+	for _, update := range ao.Observation.ChainFeeUpdates {
+		if update.ChainFee.ExecutionFeePriceUSD == nil || update.ChainFee.ExecutionFeePriceUSD.Cmp(big.NewInt(0)) <= 0 {
+			return fmt.Errorf("nil or non-positive %s", "execution fee price")
+		}
+
+		if update.ChainFee.DataAvFeePriceUSD == nil || update.ChainFee.DataAvFeePriceUSD.Cmp(big.NewInt(0)) < 0 {
+			return fmt.Errorf("nil or negative %s", "data availability fee price")
+		}
+		if update.Timestamp.IsZero() {
+			return fmt.Errorf("zero timestamp")
+		}
+	}
+	return nil
+}
+
+func validateFeeComponents(
+	ao plugincommon.AttributedObservation[Observation],
+) error {
+	for _, feeComponent := range ao.Observation.FeeComponents {
+		if feeComponent.ExecutionFee == nil || feeComponent.ExecutionFee.Cmp(big.NewInt(0)) <= 0 {
 			return fmt.Errorf("nil or non-positive %s", "execution fee")
 		}
 
-		if feeComponent.DataAvailabilityFee == nil || feeComponent.DataAvailabilityFee.Cmp(zero) < 0 {
+		if feeComponent.DataAvailabilityFee == nil || feeComponent.DataAvailabilityFee.Cmp(big.NewInt(0)) < 0 {
 			return fmt.Errorf("nil or negative %s", "data availability fee")
 		}
 	}
+	return nil
+}
 
-	for _, token := range obs.NativeTokenPrices {
-		if token.Int == nil || token.Int.Cmp(zero) <= 0 {
-			return fmt.Errorf("nil or non-positive %s", "execution fee")
+func (p *processor) ValidateObservedChains(
+	ao plugincommon.AttributedObservation[Observation],
+) error {
+	obs := ao.Observation
+	observerSupportedChains, err := p.chainSupport.SupportedChains(ao.OracleID)
+	if err != nil {
+		return fmt.Errorf("failed to get supported chains: %w", err)
+	}
+
+	observedChains := append(maps.Keys(obs.FeeComponents), maps.Keys(obs.NativeTokenPrices)...)
+	observedChains = append(observedChains, maps.Keys(obs.ChainFeeUpdates)...)
+	for _, chain := range observedChains {
+		if !observerSupportedChains.Contains(chain) {
+			return fmt.Errorf("chain %d is not supported by observer", chain)
 		}
 	}
 

commit/chainfee/validate_observation_test.go

@@ -0,0 +1,178 @@
+package chainfee
+
+import (
+	"math/big"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/types"
+
+	"github.com/smartcontractkit/chainlink-ccip/internal/plugincommon"
+	"github.com/smartcontractkit/chainlink-ccip/pkg/types/ccipocr3"
+)
+
+func Test_validateFeeComponentsAndChainFeeUpdates(t *testing.T) {
+	fourHoursAgo := time.Now().Add(-4 * time.Hour).UTC().Truncate(time.Hour)
+	tests := []struct {
+		name                         string
+		feeComponents                map[ccipocr3.ChainSelector]types.ChainFeeComponents
+		chainFeeUpdates              map[ccipocr3.ChainSelector]Update
+		expectedFeeComponentError    string
+		expectedChainFeeUpdatesError string
+	}{
+		{
+			name: "valid fee components",
+			feeComponents: map[ccipocr3.ChainSelector]types.ChainFeeComponents{
+				1: {
+					ExecutionFee:        big.NewInt(10),
+					DataAvailabilityFee: big.NewInt(20),
+				},
+			},
+			expectedFeeComponentError: "",
+		},
+		{
+			name: "nil execution fee",
+			feeComponents: map[ccipocr3.ChainSelector]types.ChainFeeComponents{
+				1: {
+					ExecutionFee:        nil,
+					DataAvailabilityFee: big.NewInt(20),
+				},
+			},
+			expectedFeeComponentError: "nil or non-positive execution fee",
+		},
+		{
+			name: "non-positive execution fee",
+			feeComponents: map[ccipocr3.ChainSelector]types.ChainFeeComponents{
+				1: {
+					ExecutionFee:        big.NewInt(0),
+					DataAvailabilityFee: big.NewInt(20),
+				},
+			},
+			expectedFeeComponentError: "nil or non-positive execution fee",
+		},
+		{
+			name: "nil data availability fee",
+			feeComponents: map[ccipocr3.ChainSelector]types.ChainFeeComponents{
+				1: {
+					ExecutionFee:        big.NewInt(10),
+					DataAvailabilityFee: nil,
+				},
+			},
+			expectedFeeComponentError: "nil or negative data availability fee",
+		},
+		{
+			name: "negative data availability fee",
+			feeComponents: map[ccipocr3.ChainSelector]types.ChainFeeComponents{
+				1: {
+					ExecutionFee:        big.NewInt(10),
+					DataAvailabilityFee: big.NewInt(-1),
+				},
+			},
+			expectedFeeComponentError: "nil or negative data availability fee",
+		},
+		{
+			name: "valid chain fee updates",
+			chainFeeUpdates: map[ccipocr3.ChainSelector]Update{
+				1: {
+					ChainFee: ComponentsUSDPrices{
+						ExecutionFeePriceUSD: big.NewInt(10),
+						DataAvFeePriceUSD:    big.NewInt(20),
+					},
+					Timestamp: fourHoursAgo,
+				},
+			},
+			expectedChainFeeUpdatesError: "",
+		},
+		{
+			name: "nil execution fee price - chain fee updates",
+			chainFeeUpdates: map[ccipocr3.ChainSelector]Update{
+				1: {
+					ChainFee: ComponentsUSDPrices{
+						ExecutionFeePriceUSD: nil,
+						DataAvFeePriceUSD:    big.NewInt(20),
+					},
+					Timestamp: fourHoursAgo,
+				},
+			},
+			expectedChainFeeUpdatesError: "nil or non-positive execution fee price",
+		},
+		{
+			name: "non-positive execution fee price - chain fee updates",
+			chainFeeUpdates: map[ccipocr3.ChainSelector]Update{
+				1: {
+					ChainFee: ComponentsUSDPrices{
+						ExecutionFeePriceUSD: big.NewInt(0),
+						DataAvFeePriceUSD:    big.NewInt(20),
+					},
+					Timestamp: fourHoursAgo,
+				},
+			},
+			expectedChainFeeUpdatesError: "nil or non-positive execution fee price",
+		},
+		{
+			name: "nil data availability fee price - chain fee updates",
+			chainFeeUpdates: map[ccipocr3.ChainSelector]Update{
+				1: {
+					ChainFee: ComponentsUSDPrices{
+						ExecutionFeePriceUSD: big.NewInt(10),
+						DataAvFeePriceUSD:    nil,
+					},
+					Timestamp: fourHoursAgo,
+				},
+			},
+			expectedChainFeeUpdatesError: "nil or negative data availability fee price",
+		},
+		{
+			name: "negative data availability fee price - chain fee updates",
+			chainFeeUpdates: map[ccipocr3.ChainSelector]Update{
+				1: {
+					ChainFee: ComponentsUSDPrices{
+						ExecutionFeePriceUSD: big.NewInt(10),
+						DataAvFeePriceUSD:    big.NewInt(-1),
+					},
+					Timestamp: fourHoursAgo,
+				},
+			},
+			expectedChainFeeUpdatesError: "nil or negative data availability fee price",
+		},
+		{
+			name: "zero timestamp - chain fee updates",
+			chainFeeUpdates: map[ccipocr3.ChainSelector]Update{
+				1: {
+					ChainFee: ComponentsUSDPrices{
+						ExecutionFeePriceUSD: big.NewInt(10),
+						DataAvFeePriceUSD:    big.NewInt(20),
+					},
+				},
+			},
+			expectedChainFeeUpdatesError: "zero timestamp",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ao := plugincommon.AttributedObservation[Observation]{
+				Observation: Observation{
+					FeeComponents:   tt.feeComponents,
+					ChainFeeUpdates: tt.chainFeeUpdates,
+				},
+			}
+			err := validateFeeComponents(ao)
+			if tt.expectedFeeComponentError == "" {
+				require.NoError(t, err)
+			} else {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), tt.expectedFeeComponentError)
+			}
+			err = validateChainFeeUpdates(ao)
+			if tt.expectedChainFeeUpdatesError == "" {
+				require.NoError(t, err)
+			} else {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), tt.expectedChainFeeUpdatesError)
+			}
+		})
+	}
+}