feat: improved chain meta reporting algo

Author: 0xNilesh

test/integration/uexecutor/vote_chain_meta_test.go

@@ -149,6 +149,159 @@ func TestVoteChainMetaIntegration(t *testing.T) {
 	})
 }
 
+// TestVoteChainMetaStalenessFilter verifies that validators whose observedAt timestamp
+// deviates from the median by more than ObservedAtStalenessThresholdSeconds are excluded
+// from the price median computation.
+// Using wall-clock seconds (observedAt) is chain-agnostic: it works identically for
+// Solana (0.4 s/block) and Bitcoin (600 s/block) without per-chain configuration.
+func TestVoteChainMetaStalenessFilter(t *testing.T) {
+	t.Parallel()
+	chainId := "eip155:11155111"
+	// threshold in seconds (300s = 5 minutes)
+	threshold := uexecutortypes.ObservedAtStalenessThresholdSeconds
+
+	t.Run("stale validator excluded when observedAt beyond staleness threshold", func(t *testing.T) {
+		testApp, ctx, uvals, vals := setupVoteChainMetaTest(t, 3)
+
+		// Base timestamp for "current" validators.
+		baseTs := uint64(1_700_000_000)
+		// val0: current (ts=baseTs,       price=200, height=1000)
+		// val1: stale   (ts=baseTs-threshold-5, price=250, height=900) → must be excluded
+		// val2: current (ts=baseTs+1,     price=300, height=1001)
+		//
+		// Median observedAt = baseTs.
+		// val1 diff = baseTs - (baseTs-threshold-5) = threshold+5 > threshold → excluded.
+		//
+		// Without filtering: sorted prices [200, 250, 300] → median=250 (stale val1)
+		// With filtering:    val1 excluded  sorted [200, 300] → median=300 (val2)
+		staleTs := baseTs - threshold - 5
+		votes := []struct {
+			price      uint64
+			height     uint64
+			observedAt uint64
+		}{
+			{200, 1000, baseTs},
+			{250, 900, staleTs},  // stale
+			{300, 1001, baseTs + 1},
+		}
+
+		for i, v := range votes {
+			coreVal, _ := sdk.ValAddressFromBech32(vals[i].OperatorAddress)
+			coreAcc := sdk.AccAddress(coreVal).String()
+			require.NoError(t, utils.ExecVoteChainMeta(t, ctx, testApp, uvals[i], coreAcc, chainId, v.price, v.height, v.observedAt))
+		}
+
+		stored, found, err := testApp.UexecutorKeeper.GetChainMeta(ctx, chainId)
+		require.NoError(t, err)
+		require.True(t, found)
+
+		// The chosen validator must NOT be the stale one.
+		// With filtering the median price is 300 (val2, height=1001).
+		require.Equal(t, uint64(300), stored.Prices[stored.MedianIndex],
+			"median price should come from a current validator, not the stale one")
+		require.Equal(t, uint64(1001), stored.ChainHeights[stored.MedianIndex],
+			"co-indexed height must be from a current validator")
+	})
+
+	t.Run("validator exactly at threshold boundary is included", func(t *testing.T) {
+		testApp, ctx, uvals, vals := setupVoteChainMetaTest(t, 3)
+
+		baseTs := uint64(1_700_000_000)
+		// val1 is exactly threshold seconds behind the median → diff == threshold → included (<=)
+		exactBoundaryTs := baseTs - threshold
+		votes := []struct {
+			price      uint64
+			height     uint64
+			observedAt uint64
+		}{
+			{200, 1000, baseTs},
+			{250, 990, exactBoundaryTs}, // diff == threshold → still included
+			{300, 1001, baseTs + 1},
+		}
+
+		for i, v := range votes {
+			coreVal, _ := sdk.ValAddressFromBech32(vals[i].OperatorAddress)
+			coreAcc := sdk.AccAddress(coreVal).String()
+			require.NoError(t, utils.ExecVoteChainMeta(t, ctx, testApp, uvals[i], coreAcc, chainId, v.price, v.height, v.observedAt))
+		}
+
+		stored, found, err := testApp.UexecutorKeeper.GetChainMeta(ctx, chainId)
+		require.NoError(t, err)
+		require.True(t, found)
+
+		// All three included → sorted prices [200, 250, 300] → median = 250 (val1)
+		require.Equal(t, uint64(250), stored.Prices[stored.MedianIndex],
+			"boundary validator should be included in median computation")
+	})
+
+	t.Run("all validators current: filtering does not change median", func(t *testing.T) {
+		testApp, ctx, uvals, vals := setupVoteChainMetaTest(t, 4)
+
+		// All timestamps are close together (within threshold).
+		// Result must match an unfiltered median.
+		baseTs := uint64(1_700_000_000)
+		votes := []struct {
+			price      uint64
+			height     uint64
+			observedAt uint64
+		}{
+			{300, 1000, baseTs},
+			{200, 1001, baseTs + 1},
+			{400, 1002, baseTs + 2},
+			{250, 999, baseTs - 1},
+		}
+
+		for i, v := range votes {
+			coreVal, _ := sdk.ValAddressFromBech32(vals[i].OperatorAddress)
+			coreAcc := sdk.AccAddress(coreVal).String()
+			require.NoError(t, utils.ExecVoteChainMeta(t, ctx, testApp, uvals[i], coreAcc, chainId, v.price, v.height, v.observedAt))
+		}
+
+		stored, found, err := testApp.UexecutorKeeper.GetChainMeta(ctx, chainId)
+		require.NoError(t, err)
+		require.True(t, found)
+
+		// All current → sorted [200, 250, 300, 400] → upper-median (index 2) = 300
+		require.Equal(t, uint64(300), stored.Prices[stored.MedianIndex])
+		// Co-indexed height must belong to the same validator (height=1000)
+		require.Equal(t, uint64(1000), stored.ChainHeights[stored.MedianIndex])
+	})
+
+	t.Run("multiple stale validators excluded, median from current set", func(t *testing.T) {
+		testApp, ctx, uvals, vals := setupVoteChainMetaTest(t, 5)
+
+		// 3 current validators, 2 stale (observedAt > threshold seconds behind)
+		baseTs := uint64(1_700_000_000)
+		staleTs := baseTs - threshold - 10
+		votes := []struct {
+			price      uint64
+			height     uint64
+			observedAt uint64
+		}{
+			{500, 1000, baseTs},     // current
+			{100, 800, staleTs},     // stale → excluded
+			{300, 1001, baseTs + 1}, // current
+			{150, 810, staleTs},     // stale → excluded
+			{200, 1002, baseTs + 2}, // current
+		}
+
+		for i, v := range votes {
+			coreVal, _ := sdk.ValAddressFromBech32(vals[i].OperatorAddress)
+			coreAcc := sdk.AccAddress(coreVal).String()
+			require.NoError(t, utils.ExecVoteChainMeta(t, ctx, testApp, uvals[i], coreAcc, chainId, v.price, v.height, v.observedAt))
+		}
+
+		stored, found, err := testApp.UexecutorKeeper.GetChainMeta(ctx, chainId)
+		require.NoError(t, err)
+		require.True(t, found)
+
+		// After excluding the two stale validators, current set prices: [500, 300, 200]
+		// Sorted: [200, 300, 500] → upper-median (index 1) = 300 (val with height=1001)
+		require.Equal(t, uint64(300), stored.Prices[stored.MedianIndex])
+		require.Equal(t, uint64(1001), stored.ChainHeights[stored.MedianIndex])
+	})
+}
+
 func TestMigrateGasPricesToChainMeta(t *testing.T) {
 	chainId := "eip155:11155111"
 

x/uexecutor/keeper/chain_meta.go

@@ -51,14 +51,11 @@ func (k Keeper) VoteChainMeta(ctx context.Context, universalValidator sdk.ValAdd
 			return sdkerrors.Wrap(err, "failed to set initial chain meta entry")
 		}
 
-		// EVM call with single price
 		priceBig := math.NewUint(price).BigInt()
 		chainHeightBig := math.NewUint(blockNumber).BigInt()
 		observedAtBig := math.NewUint(observedAt).BigInt()
 		if _, evmErr := k.CallUniversalCoreSetChainMeta(sdkCtx, observedChainId, priceBig, chainHeightBig, observedAtBig); evmErr != nil {
-			// Non-fatal: log the error. The EVM call may fail if the contract hasn't been upgraded yet
-			// (old bytecode only has setGasPrice). State is still persisted.
-			sdkCtx.Logger().Error("VoteChainMeta: EVM setChainMeta call failed", "chain", observedChainId, "error", evmErr)
+			return sdkerrors.Wrap(evmErr, "failed to call EVM setChainMeta")
 		}
 
 		return nil
@@ -83,20 +80,24 @@ func (k Keeper) VoteChainMeta(ctx context.Context, universalValidator sdk.ValAdd
 		entry.ObservedAts = append(entry.ObservedAts, observedAt)
 	}
 
-	// Recompute median on price
-	medianIdx := computeMedianIndex(entry.Prices)
+	// Recompute median: filter out stale validators first, then median on price.
+	// Staleness is measured by observedAt (Unix seconds) — chain-agnostic.
+	// See computeMedianIndexFiltered for the two-step algorithm.
+	medianIdx := computeMedianIndexFiltered(entry.Prices, entry.ObservedAts)
 	entry.MedianIndex = uint64(medianIdx)
 
 	if err := k.SetChainMeta(ctx, observedChainId, entry); err != nil {
 		return sdkerrors.Wrap(err, "failed to set updated chain meta entry")
 	}
 
+	// 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()
-	medianChainHeight := math.NewUint(entry.ChainHeights[medianIdx]).BigInt()
-	medianObservedAt := math.NewUint(entry.ObservedAts[medianIdx]).BigInt()
-	if _, evmErr := k.CallUniversalCoreSetChainMeta(sdkCtx, observedChainId, medianPrice, medianChainHeight, medianObservedAt); evmErr != nil {
-		// Non-fatal: log. Same forward-compat reason as above.
-		sdkCtx.Logger().Error("VoteChainMeta: EVM setChainMeta call failed", "chain", observedChainId, "error", evmErr)
+	coChainHeight := math.NewUint(entry.ChainHeights[medianIdx]).BigInt()
+	coObservedAt := math.NewUint(entry.ObservedAts[medianIdx]).BigInt()
+	if _, evmErr := k.CallUniversalCoreSetChainMeta(sdkCtx, observedChainId, medianPrice, coChainHeight, coObservedAt); evmErr != nil {
+		return sdkerrors.Wrap(evmErr, "failed to call EVM setChainMeta")
 	}
 
 	return nil

x/uexecutor/keeper/gas_price.go

@@ -11,6 +11,7 @@ import (
 	sdkerrors "cosmossdk.io/errors"
 	"cosmossdk.io/math"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+
 	"github.com/pushchain/push-chain-node/x/uexecutor/types"
 )
 
@@ -108,3 +109,56 @@ func computeMedianIndex(values []uint64) int {
 	sort.SliceStable(arr, func(i, j int) bool { return arr[i].Val < arr[j].Val })
 	return arr[len(arr)/2].Idx
 }
+
+// computeMedianIndexFiltered returns the original index (into prices/observedAts)
+// of the validator chosen as the representative for VoteChainMeta. The selection
+// is a two-step process:
+//
+//  1. Compute the median of observedAt timestamps across all validators.
+//  2. Exclude validators whose observedAt deviates from that median by more than
+//     ObservedAtStalenessThresholdSeconds (they are considered lagging / stale).
+//     Using wall-clock seconds is chain-agnostic: it works identically for Solana
+//     (0.4 s/block) and Bitcoin (600 s/block) without per-chain configuration.
+//  3. Among the remaining validators compute the median of prices and return that
+//     validator's original index.
+//
+// The returned index is valid for all three parallel slices (prices, chainHeights,
+// observedAts), so the caller gets a coherent (price, height, timestamp) tuple
+// from a single validator who is both current and representative on price.
+//
+// If – after filtering – no candidates remain (should not happen with a sensible
+// threshold), the function falls back to computeMedianIndex on the full price slice.
+func computeMedianIndexFiltered(prices, observedAts []uint64) int {
+	// Step 1: median observedAt timestamp across all validators
+	medianObservedAtIdx := computeMedianIndex(observedAts)
+	medianObservedAt := observedAts[medianObservedAtIdx]
+
+	// Step 2: keep only validators within the staleness threshold (in seconds)
+	type candidate struct {
+		originalIdx int
+		price       uint64
+	}
+	var candidates []candidate
+	for i, ts := range observedAts {
+		var diff uint64
+		if ts >= medianObservedAt {
+			diff = ts - medianObservedAt
+		} else {
+			diff = medianObservedAt - ts
+		}
+		if diff <= types.ObservedAtStalenessThresholdSeconds {
+			candidates = append(candidates, candidate{i, prices[i]})
+		}
+	}
+
+	// Fallback: threshold filtered everyone out (should not happen)
+	if len(candidates) == 0 {
+		return computeMedianIndex(prices)
+	}
+
+	// Step 3: median of prices among current validators
+	sort.SliceStable(candidates, func(i, j int) bool {
+		return candidates[i].price < candidates[j].price
+	})
+	return candidates[len(candidates)/2].originalIdx
+}

x/uexecutor/types/constants.go

@@ -40,6 +40,11 @@ const (
 
 	// Default number of blocks after which ballot expires
 	DefaultExpiryAfterBlocks = 10000
+
+	// ObservedAtStalenessThresholdSeconds is the maximum number of seconds a
+	// validator's observedAt timestamp may deviate from the median observedAt before
+	// its price vote is excluded from the median price computation in VoteChainMeta.
+	ObservedAtStalenessThresholdSeconds uint64 = 300
 )
 
 var UniversalTxOutboundEventSig = crypto.Keccak256Hash([]byte(