feat: improved chain meta reporting algo

Author: 0xNilesh

test/integration/uexecutor/vote_chain_meta_test.go

@@ -415,3 +415,79 @@ func TestVoteChainMetaContractState(t *testing.T) {
 		require.Equal(t, new(big.Int).SetUint64(observedAt), got)
 	})
 }
+
+// TestVoteChainMetaAbsoluteStaleness verifies that when all validators' observedAt timestamps
+// are older than ObservedAtStalenessThresholdSeconds relative to the current block time,
+// the EVM contract is NOT updated (it retains its previous value).
+//
+// These tests call VoteChainMeta directly on the keeper (bypassing authz) so that
+// block time can be freely manipulated without hitting authz grant expiry.
+func TestVoteChainMetaAbsoluteStaleness(t *testing.T) {
+	chainId := "eip155:11155111"
+	threshold := uexecutortypes.ObservedAtStalenessThresholdSeconds // 300
+
+	universalCoreAddr := utils.GetDefaultAddresses().HandlerAddr
+
+	readGasPrice := func(t *testing.T, testApp *app.ChainApp, ctx sdk.Context) *big.Int {
+		t.Helper()
+		ucABI, err := uexecutortypes.ParseUniversalCoreABI()
+		require.NoError(t, err)
+		caller, _ := testApp.UexecutorKeeper.GetUeModuleAddress(ctx)
+		res, err := testApp.EVMKeeper.CallEVM(ctx, ucABI, caller, universalCoreAddr, false, "gasPriceByChainNamespace", chainId)
+		require.NoError(t, err)
+		return new(big.Int).SetBytes(res.Ret)
+	}
+
+	t.Run("stale single vote does not update contract", func(t *testing.T) {
+		testApp, ctx, _, vals := setupVoteChainMetaTest(t, 1)
+
+		staleObservedAt := uint64(1_700_000_000)
+		// Block time is far past the staleness window
+		staleCtx := ctx.WithBlockTime(time.Unix(int64(staleObservedAt+threshold+60), 0))
+
+		valAddr, err := sdk.ValAddressFromBech32(vals[0].OperatorAddress)
+		require.NoError(t, err)
+
+		require.NoError(t, testApp.UexecutorKeeper.VoteChainMeta(staleCtx, valAddr, chainId,
+			100_000_000_000, 12345, staleObservedAt))
+
+		// Vote was stored in state
+		stored, found, err := testApp.UexecutorKeeper.GetChainMeta(staleCtx, chainId)
+		require.NoError(t, err)
+		require.True(t, found)
+		require.Equal(t, uint64(100_000_000_000), stored.Prices[0])
+
+		// Contract must NOT have been updated — should still be 0
+		require.Zero(t, readGasPrice(t, testApp, staleCtx).Sign(),
+			"contract must not be updated when all validators are stale")
+	})
+
+	t.Run("all validators stale does not update contract", func(t *testing.T) {
+		testApp, ctx, _, vals := setupVoteChainMetaTest(t, 3)
+
+		freshObservedAt := uint64(1_700_000_000)
+
+		// First vote with fresh block time → contract gets updated
+		freshCtx := ctx.WithBlockTime(time.Unix(int64(freshObservedAt), 0))
+		for i := 0; i < 3; i++ {
+			valAddr, err := sdk.ValAddressFromBech32(vals[i].OperatorAddress)
+			require.NoError(t, err)
+			require.NoError(t, testApp.UexecutorKeeper.VoteChainMeta(freshCtx, valAddr, chainId,
+				200_000_000_000, uint64(12345+i), freshObservedAt+uint64(i)))
+		}
+		require.Equal(t, new(big.Int).SetUint64(200_000_000_000), readGasPrice(t, testApp, freshCtx))
+
+		// Re-vote with same old timestamps but block time past staleness window
+		futureCtx := ctx.WithBlockTime(time.Unix(int64(freshObservedAt+threshold+60), 0))
+		for i := 0; i < 3; i++ {
+			valAddr, err := sdk.ValAddressFromBech32(vals[i].OperatorAddress)
+			require.NoError(t, err)
+			require.NoError(t, testApp.UexecutorKeeper.VoteChainMeta(futureCtx, valAddr, chainId,
+				999_000_000_000, uint64(99999+i), freshObservedAt+uint64(i)))
+		}
+
+		// Contract must retain the old fresh value — stale votes must not overwrite it
+		require.Equal(t, new(big.Int).SetUint64(200_000_000_000), readGasPrice(t, testApp, futureCtx),
+			"contract must retain last good value when all validators report stale data")
+	})
+}

x/uexecutor/keeper/chain_meta.go

@@ -26,8 +26,26 @@ func (k Keeper) SetChainMeta(ctx context.Context, chainID string, chainMeta type
 	return k.ChainMetas.Set(ctx, chainID, chainMeta)
 }
 
+// isObservedAtStale returns true if observedAt (Unix seconds) is older than
+// ObservedAtStalenessThresholdSeconds relative to the current block time.
+// When true the data should not be pushed to the UniversalCore contract.
+// Returns false when block time is zero or negative (not yet configured).
+func isObservedAtStale(sdkCtx sdk.Context, observedAt uint64) bool {
+	blockTimeUnix := sdkCtx.BlockTime().Unix()
+	if blockTimeUnix <= 0 {
+		// Block time not configured (e.g. genesis or test setup) — skip staleness check.
+		return false
+	}
+	blockTimeSec := uint64(blockTimeUnix)
+	return blockTimeSec > observedAt &&
+		blockTimeSec-observedAt > types.ObservedAtStalenessThresholdSeconds
+}
+
 // VoteChainMeta processes a universal validator's vote on chain metadata (gas price + chain height + observed timestamp).
 // It accumulates votes, computes the median price, and calls setChainMeta on the UniversalCore contract.
+// If the median observedAt is older than ObservedAtStalenessThresholdSeconds relative to the current
+// block time, the EVM contract is NOT updated — all validators are considered stale and retaining
+// the last good contract state is preferred over pushing stale data.
 func (k Keeper) VoteChainMeta(ctx context.Context, universalValidator sdk.ValAddress, observedChainId string, price, blockNumber, observedAt uint64) error {
 	sdkCtx := sdk.UnwrapSDKContext(ctx)
 
@@ -51,6 +69,12 @@ func (k Keeper) VoteChainMeta(ctx context.Context, universalValidator sdk.ValAdd
 			return sdkerrors.Wrap(err, "failed to set initial chain meta entry")
 		}
 
+		if isObservedAtStale(sdkCtx, observedAt) {
+			sdkCtx.Logger().Info("VoteChainMeta: skipping EVM update — single vote is stale",
+				"chain", observedChainId, "observedAt", observedAt)
+			return nil
+		}
+
 		priceBig := math.NewUint(price).BigInt()
 		chainHeightBig := math.NewUint(blockNumber).BigInt()
 		observedAtBig := math.NewUint(observedAt).BigInt()
@@ -90,12 +114,23 @@ func (k Keeper) VoteChainMeta(ctx context.Context, universalValidator sdk.ValAdd
 		return sdkerrors.Wrap(err, "failed to set updated chain meta entry")
 	}
 
+	// If the median observedAt is stale relative to the current block time, all
+	// validators are considered offline/lagging. Skip the EVM update so the
+	// contract retains its last known good value rather than being overwritten
+	// with stale data.
+	medianObservedAt := entry.ObservedAts[medianIdx]
+	if isObservedAtStale(sdkCtx, medianObservedAt) {
+		sdkCtx.Logger().Info("VoteChainMeta: skipping EVM update — all validators stale",
+			"chain", observedChainId, "medianObservedAt", medianObservedAt)
+		return nil
+	}
+
 	// Use the full observation tuple from the median-price validator.
 	// chainHeight and observedAt are NOT independent medians — they are the
 	// co-indexed values from whichever validator submitted the median price.
 	medianPrice := math.NewUint(entry.Prices[medianIdx]).BigInt()
 	coChainHeight := math.NewUint(entry.ChainHeights[medianIdx]).BigInt()
-	coObservedAt := math.NewUint(entry.ObservedAts[medianIdx]).BigInt()
+	coObservedAt := math.NewUint(medianObservedAt).BigInt()
 	if _, evmErr := k.CallUniversalCoreSetChainMeta(sdkCtx, observedChainId, medianPrice, coChainHeight, coObservedAt); evmErr != nil {
 		return sdkerrors.Wrap(evmErr, "failed to call EVM setChainMeta")
 	}