Bridge patch (#992) (#994)

* set bridgev2 upgrade addresses

* allow pre-upgrade deposits to be claimed

* upgrade handler

* removed upgrade to allow for a straight binary switch to upgrade to include this fix

---------



(cherry picked from commit 4ba4972)

Co-authored-by: tkernell <tpkernell@gmail.com>
Co-authored-by: danflo27 <florentinodc@outlook.com>
Co-authored-by: Cjpotter10 <caleb10joseph@gmail.com>

Author: 4 people

x/bridge/keeper/claim_deposit.go

@@ -15,6 +15,7 @@ import (
 	layer "github.com/tellor-io/layer/types"
 	"github.com/tellor-io/layer/x/bridge/types"
 	oraclemodule "github.com/tellor-io/layer/x/oracle/keeper"
+	oracletypes "github.com/tellor-io/layer/x/oracle/types"
 	registrytypes "github.com/tellor-io/layer/x/registry/types"
 
 	"cosmossdk.io/collections"
@@ -25,11 +26,7 @@ import (
 
 func (k Keeper) ClaimDeposit(ctx context.Context, depositId, timestamp uint64) error {
 	cosmosCtx := sdk.UnwrapSDKContext(ctx)
-	queryId, err := k.GetDepositQueryId(depositId)
-	if err != nil {
-		return err
-	}
-	aggregate, err := k.oracleKeeper.GetAggregateByTimestamp(ctx, queryId, timestamp)
+	_, aggregate, err := k.ResolveDepositAggregateByTimestamp(ctx, depositId, timestamp)
 	if err != nil {
 		return err
 	}
@@ -98,8 +95,29 @@ func (k Keeper) ClaimDeposit(ctx context.Context, depositId, timestamp uint64) e
 	return nil
 }
 
-// replicate solidity encoding,  keccak256(abi.encode(string "TRBBridgeV2", abi.encode(bool true, uint256 depositId)))
-func (k Keeper) GetDepositQueryId(depositId uint64) ([]byte, error) {
+func (k Keeper) ResolveDepositAggregateByTimestamp(ctx context.Context, depositId, timestamp uint64) ([]byte, oracletypes.Aggregate, error) {
+	// Prefer V2, but allow legacy V1 query IDs so pre-upgrade deposits remain claimable.
+	candidateQueryTypes := []string{oraclemodule.TRBBridgeV2QueryType, oraclemodule.TRBBridgeQueryType}
+	var lastErr error
+	for _, queryType := range candidateQueryTypes {
+		queryId, err := k.GetDepositQueryIdByType(depositId, queryType)
+		if err != nil {
+			return nil, oracletypes.Aggregate{}, err
+		}
+		aggregate, err := k.oracleKeeper.GetAggregateByTimestamp(ctx, queryId, timestamp)
+		if err == nil {
+			return queryId, aggregate, nil
+		}
+		lastErr = err
+	}
+	if lastErr != nil {
+		return nil, oracletypes.Aggregate{}, lastErr
+	}
+	return nil, oracletypes.Aggregate{}, fmt.Errorf("aggregate not found for deposit id %d at timestamp %d", depositId, timestamp)
+}
+
+// replicate solidity encoding,  keccak256(abi.encode(string queryType, abi.encode(bool true, uint256 depositId)))
+func (k Keeper) GetDepositQueryIdByType(depositId uint64, queryType string) ([]byte, error) {
 	toLayerBool := true
 	depositIdUint64 := new(big.Int).SetUint64(depositId)
 
@@ -136,7 +154,7 @@ func (k Keeper) GetDepositQueryId(depositId uint64) ([]byte, error) {
 		{Type: StringType},
 		{Type: BytesType},
 	}
-	queryDataEncoded, err := finalArgs.Pack(oraclemodule.TRBBridgeV2QueryType, queryDataArgsEncoded)
+	queryDataEncoded, err := finalArgs.Pack(queryType, queryDataArgsEncoded)
 	if err != nil {
 		return nil, err
 	}
@@ -146,6 +164,11 @@ func (k Keeper) GetDepositQueryId(depositId uint64) ([]byte, error) {
 	return queryId, nil
 }
 
+// GetDepositQueryId returns the TRBBridgeV2 query ID for a deposit id.
+func (k Keeper) GetDepositQueryId(depositId uint64) ([]byte, error) {
+	return k.GetDepositQueryIdByType(depositId, oraclemodule.TRBBridgeV2QueryType)
+}
+
 // replicate solidity decoding, abi.decode(reportValue, (address ethSender, string layerRecipient, uint256 amount, uint256 tip))
 func (k Keeper) DecodeDepositReportValue(ctx context.Context, reportValue string) (recipient sdk.AccAddress, amount, tip sdk.Coins, err error) {
 	// prepare decoding

x/bridge/keeper/claim_deposit_test.go

@@ -262,13 +262,71 @@ func TestClaimDepositNilAggregate(t *testing.T) {
 	sdkCtx := sdk.UnwrapSDKContext(ctx)
 	k.SetValsetCheckpointDomainSeparator(sdkCtx)
 
-	queryId, _ := k.GetDepositQueryId(0)
+	queryIdV2, _ := k.GetDepositQueryId(0)
+	queryIdV1, _ := k.GetDepositQueryIdByType(0, "TRBBridge")
 	currentTime := time.Now()
-	ok.On("GetAggregateByTimestamp", sdkCtx, queryId, uint64(currentTime.UnixMilli())).Return(oracletypes.Aggregate{}, collections.ErrNotFound)
+	ok.On("GetAggregateByTimestamp", sdkCtx, queryIdV2, uint64(currentTime.UnixMilli())).Return(oracletypes.Aggregate{}, collections.ErrNotFound)
+	ok.On("GetAggregateByTimestamp", sdkCtx, queryIdV1, uint64(currentTime.UnixMilli())).Return(oracletypes.Aggregate{}, collections.ErrNotFound)
 	err := k.ClaimDeposit(ctx, 0, uint64(currentTime.UnixMilli()))
 	require.ErrorContains(t, err, "not found")
 }
 
+func TestClaimDepositFallsBackToLegacyTRBBridgeQueryId(t *testing.T) {
+	k, _, bk, ok, _, _, _, ctx := setupKeeper(t)
+	require.NotNil(t, k)
+	require.NotNil(t, ctx)
+	sdkCtx := sdk.UnwrapSDKContext(ctx)
+	k.SetValsetCheckpointDomainSeparator(sdkCtx)
+
+	aggregateTimestamp := sdkCtx.BlockTime()
+	AddressType, err := abi.NewType("address", "", nil)
+	require.NoError(t, err)
+	Uint256Type, err := abi.NewType("uint256", "", nil)
+	require.NoError(t, err)
+	StringType, err := abi.NewType("string", "", nil)
+	require.NoError(t, err)
+	reportValueArgs := abi.Arguments{
+		{Type: AddressType},
+		{Type: StringType},
+		{Type: Uint256Type},
+	}
+	ethAddress := common.HexToAddress("0x3386518F7ab3eb51591571adBE62CF94540EAd29")
+	layerAddressString := simtestutil.CreateIncrementalAccounts(1)[0].String()
+	amountUint64 := big.NewInt(100 * 1e12)
+	reportValueArgsEncoded, err := reportValueArgs.Pack(ethAddress, layerAddressString, amountUint64)
+	require.NoError(t, err)
+	reportValueString := hex.EncodeToString(reportValueArgsEncoded)
+
+	queryIdV2, err := k.GetDepositQueryId(0)
+	require.NoError(t, err)
+	queryIdV1, err := k.GetDepositQueryIdByType(0, "TRBBridge")
+	require.NoError(t, err)
+
+	aggregate := oracletypes.Aggregate{
+		QueryId:        queryIdV1,
+		AggregateValue: reportValueString,
+		AggregatePower: uint64(68),
+	}
+	powerThreshold := uint64(67)
+	validatorTimestamp := uint64(aggregateTimestamp.UnixMilli() - 1)
+	valSetHash := []byte("valSetHash")
+	_, err = k.CalculateValidatorSetCheckpoint(ctx, powerThreshold, validatorTimestamp, valSetHash)
+	require.NoError(t, err)
+
+	sdkCtx = sdkCtx.WithBlockTime(sdkCtx.BlockTime().Add(13 * time.Hour))
+	recipient, amount, _, err := k.DecodeDepositReportValue(ctx, reportValueString)
+	require.NoError(t, err)
+
+	// First lookup (V2) misses, second lookup (legacy V1) succeeds.
+	ok.On("GetAggregateByTimestamp", sdkCtx, queryIdV2, uint64(aggregateTimestamp.UnixMilli())).Return(oracletypes.Aggregate{}, collections.ErrNotFound)
+	ok.On("GetAggregateByTimestamp", sdkCtx, queryIdV1, uint64(aggregateTimestamp.UnixMilli())).Return(aggregate, nil)
+	bk.On("MintCoins", sdkCtx, bridgetypes.ModuleName, amount).Return(nil)
+	bk.On("SendCoinsFromModuleToAccount", sdkCtx, bridgetypes.ModuleName, recipient, amount).Return(nil)
+
+	err = k.ClaimDeposit(sdkCtx, 0, uint64(aggregateTimestamp.UnixMilli()))
+	require.NoError(t, err)
+}
+
 func TestClaimDepositFlaggedAggregate(t *testing.T) {
 	k, _, bk, ok, rk, _, _, ctx := setupKeeper(t)
 	require.NotNil(t, k)