refactor(lightclient): removed the need for next stateInfo for valiadition

go.mod

@@ -246,6 +246,5 @@ replace (
 
 	//  broken goleveldb
 	github.com/syndtr/goleveldb => github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7
-	github.com/tendermint/tendermint => github.com/cometbft/cometbft v0.34.29
 	golang.org/x/exp => golang.org/x/exp v0.0.0-20230711153332-06a737ee72cb
 )

x/lightclient/ante/ibc_msg_update_client.go

@@ -9,7 +9,6 @@
 	ibcclienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types"
 	ibctm "github.com/cosmos/ibc-go/v7/modules/light-clients/07-tendermint"
 	"github.com/dymensionxyz/dymension/v3/x/lightclient/types"
-	rollapptypes "github.com/dymensionxyz/dymension/v3/x/rollapp/types"
 	sequencertypes "github.com/dymensionxyz/dymension/v3/x/sequencer/types"
 	"github.com/dymensionxyz/gerr-cosmos/gerrc"
 )
@@ -31,6 +30,7 @@
 	if err != nil {
 		return errorsmod.Wrap(err, "get header")
 	}
+
 	seq, err := i.getSequencer(ctx, header)
 	err = errorsmod.Wrap(err, "get sequencer")
 	if errorsmod.IsOf(err, errProposerMismatch) {
@@ -74,18 +74,21 @@
 	}
 
 	h := header.GetHeight().GetRevisionHeight()
-	stateInfos, err := i.getStateInfos(ctx, rollapp.RollappId, h)
+	sInfo, err := i.raK.FindStateInfoByHeight(ctx, rollapp.RollappId, h)
+	if errorsmod.IsOf(err, gerrc.ErrNotFound) {
+		// the header is optimistic: the state update has not yet been received, so we save optimistically
+		return errorsmod.Wrap(i.k.SaveSigner(ctx, seq.Address, msg.ClientId, h), "save updater")
+	}
 	if err != nil {
-		return errorsmod.Wrap(err, "get state infos")
+		return errorsmod.Wrap(err, "find state info by height")
 	}
 
-	if stateInfos.containingHPlus1 != nil {
-		// the header is pessimistic: the state update has already been received, so we check the header doesn't mismatch
-		return errorsmod.Wrap(i.validateUpdatePessimistically(ctx, stateInfos, header.ConsensusState(), h), "validate pessimistic")
+	err = i.k.ValidateHeaderAgainstStateInfo(ctx, sInfo, header.ConsensusState(), h)
+	if err != nil {
+		return errorsmod.Wrap(err, "validate pessimistic")
 	}
 
-	// the header is optimistic: the state update has not yet been received, so we save optimistically
-	return errorsmod.Wrap(i.k.SaveSigner(ctx, seq.Address, msg.ClientId, h), "save updater")
+	return nil
 }
 
 var (
@@ -119,45 +122,3 @@
 	}
 	return header, nil
 }
-
-// if containingHPlus1 is not nil then containingH also guaranteed to not be nil
-type stateInfos struct {
-	containingH      *rollapptypes.StateInfo
-	containingHPlus1 *rollapptypes.StateInfo
-}
-
-// getStateInfos gets state infos for h and h+1
-func (i IBCMessagesDecorator) getStateInfos(ctx sdk.Context, rollapp string, h uint64) (stateInfos, error) {
-	// Check if there are existing block descriptors for the given height of client state
-	s0, err := i.raK.FindStateInfoByHeight(ctx, rollapp, h)
-	if errorsmod.IsOf(err, gerrc.ErrNotFound) {
-		return stateInfos{}, nil
-	}
-	if err != nil {
-		return stateInfos{}, err
-	}
-	s1 := s0
-	if !s1.ContainsHeight(h + 1) {
-		s1, err = i.raK.FindStateInfoByHeight(ctx, rollapp, h+1)
-		if errorsmod.IsOf(err, gerrc.ErrNotFound) {
-			return stateInfos{s0, nil}, nil
-		}
-		if err != nil {
-			return stateInfos{}, err
-		}
-	}
-	return stateInfos{s0, s1}, nil
-}
-
-func (i IBCMessagesDecorator) validateUpdatePessimistically(ctx sdk.Context, infos stateInfos, consState *ibctm.ConsensusState, h uint64) error {
-	bd, _ := infos.containingH.GetBlockDescriptor(h)
-	seq, err := i.k.SeqK.RealSequencer(ctx, infos.containingHPlus1.Sequencer)
-	if err != nil {
-		return errorsmod.Wrap(errors.Join(err, gerrc.ErrInternal), "get sequencer of state info")
-	}
-	rollappState := types.RollappState{
-		BlockDescriptor:    bd,
-		NextBlockSequencer: seq,
-	}
-	return errorsmod.Wrap(types.CheckCompatibility(*consState, rollappState), "check compatibility")
-}

x/lightclient/keeper/canonical_client.go

@@ -5,31 +5,62 @@
 
 	errorsmod "cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/types/query"
-	ibcclienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types"
 	"github.com/cosmos/ibc-go/v7/modules/core/exported"
 	ibctm "github.com/cosmos/ibc-go/v7/modules/light-clients/07-tendermint"
 
 	"github.com/dymensionxyz/dymension/v3/x/lightclient/types"
+	rollapptypes "github.com/dymensionxyz/dymension/v3/x/rollapp/types"
+	"github.com/dymensionxyz/gerr-cosmos/gerrc"
 )
 
 // GetProspectiveCanonicalClient returns the client id of the first IBC client which can be set as the canonical client for the given rollapp.
 // The canonical client criteria are:
 // 1. The client must be a tendermint client.
 // 2. The client state must match the expected client params as configured by the module
-// 3. All the existing consensus states much match the corresponding height rollapp block descriptors
-func (k Keeper) GetProspectiveCanonicalClient(ctx sdk.Context, rollappId string, maxHeight uint64) (clientID string, stateCompatible bool) {
+// 3. The client state must have the same chain id as the rollapp id.
+// 4. All the existing consensus states much match the corresponding height rollapp block descriptors
+func (k Keeper) GetProspectiveCanonicalClient(ctx sdk.Context, sInfo *rollapptypes.StateInfo) (clientID string, found bool) {
 	k.ibcClientKeeper.IterateClientStates(ctx, nil, func(client string, cs exported.ClientState) bool {
-		err := k.validClient(ctx, client, cs, rollappId, maxHeight)
-		if err != nil && !errorsmod.IsOf(err, errChainIDMismatch) {
-			ctx.Logger().Debug("tried to validate rollapp against light client for same chain id: rollapp: %s: client: %s", rollappId, client, "err", err)
+		rollappId := sInfo.GetRollappId()
+
+		tmClientState, ok := cs.(*ibctm.ClientState)
+		if !ok {
+			return false
+		}
+		if tmClientState.ChainId != rollappId {
+			return false
+		}
+
+		expClient := k.expectedClient()
+		if err := types.IsCanonicalClientParamsValid(tmClientState, &expClient); err != nil {
+			k.Logger(ctx).Debug("validate client params against light client with same chain id",
+				"rollapp", sInfo.GetRollappId(),
+				"client", client,
+				"expected", expClient,
+				"actual", tmClientState,
+				"err", err,
+			)
+			return false
+		}
+
+		// validate state info against optimistically accepted headers
+		validated, err := k.ValidateOptimisticUpdates(ctx, client, sInfo)
+		if err != nil {
+			k.Logger(ctx).Debug("validate rollapp state against light client with same chain id",
+				"rollapp", sInfo.GetRollappId(),
+				"client", client,
+				"err", err,
+			)
+			return false
 		}
-		if err == nil {
-			clientID = client
-			stateCompatible = true
-			return true
+		if !validated {
+			return false
 		}
-		return false
+
+		// we successfully validated the state info against a potential client
+		clientID = client
+		found = true
+		return true
 	})
 	return
 }
@@ -67,68 +98,18 @@
 	return types.DefaultExpectedCanonicalClientParams()
 }
 
-var errChainIDMismatch = errors.New("chain id mismatch")
-
-func (k Keeper) validClient(ctx sdk.Context, clientID string, cs exported.ClientState, rollappId string, maxHeight uint64) error {
-	tmClientState, ok := cs.(*ibctm.ClientState)
+func (k Keeper) ValidateHeaderAgainstStateInfo(ctx sdk.Context, sInfo *rollapptypes.StateInfo, consState *ibctm.ConsensusState, h uint64) error {
+	bd, ok := sInfo.GetBlockDescriptor(h)
 	if !ok {
-		return errors.New("not tm client")
+		return errorsmod.Wrapf(gerrc.ErrInternal, "no block descriptor found for height %d", h)
 	}
-	if tmClientState.ChainId != rollappId {
-		return errChainIDMismatch
-	}
-
-	expClient := k.expectedClient()
-
-	if err := types.IsCanonicalClientParamsValid(tmClientState, &expClient); err != nil {
-		return errorsmod.Wrap(err, "params")
-	}
-
-	// FIXME: No need to get all consensus states. should iterate over the consensus states
-	res, err := k.ibcClientKeeper.ConsensusStateHeights(ctx, &ibcclienttypes.QueryConsensusStateHeightsRequest{
-		ClientId:   clientID,
-		Pagination: &query.PageRequest{Limit: maxHeight},
-	})
+	nextSeq, err := k.SeqK.RealSequencer(ctx, sInfo.NextSequencerForHeight(h))
 	if err != nil {
-		return errorsmod.Wrap(err, "cons state heights")
-	}
-	atLeastOneMatch := false
-	for _, consensusHeight := range res.ConsensusStateHeights {
-		h := consensusHeight.GetRevisionHeight()
-		if maxHeight < h {
-			break
-		}
-		consensusState, _ := k.ibcClientKeeper.GetClientConsensusState(ctx, clientID, consensusHeight)
-		tmConsensusState, _ := consensusState.(*ibctm.ConsensusState)
-		stateInfoH, err := k.rollappKeeper.FindStateInfoByHeight(ctx, rollappId, h)
-		if err != nil {
-			return errorsmod.Wrapf(err, "find state info by height h: %d", h)
-		}
-		stateInfoHplus1, err := k.rollappKeeper.FindStateInfoByHeight(ctx, rollappId, h+1)
-		if err != nil {
-			return errorsmod.Wrapf(err, "find state info by height h+1: %d", h+1)
-		}
-		bd, _ := stateInfoH.GetBlockDescriptor(h)
-
-		nextSeq, err := k.SeqK.RealSequencer(ctx, stateInfoHplus1.Sequencer)
-		if err != nil {
-			return errorsmod.Wrap(err, "get sequencer")
-		}
-		rollappState := types.RollappState{
-			BlockDescriptor:    bd,
-			NextBlockSequencer: nextSeq,
-		}
-		err = types.CheckCompatibility(*tmConsensusState, rollappState)
-		if err != nil {
-			return errorsmod.Wrapf(err, "check compatibility: height: %d", h)
-		}
-		atLeastOneMatch = true
+		return errorsmod.Wrap(errors.Join(err, gerrc.ErrInternal), "get sequencer of state info")
 	}
-	// Need to be sure that at least one consensus state agrees with a state update
-	// (There are also no disagreeing consensus states. There may be some consensus states
-	// for future state updates, which will incur a fraud if they disagree.)
-	if !atLeastOneMatch {
-		return errors.New("no matching consensus state found")
+	rollappState := types.RollappState{
+		BlockDescriptor:    bd,
+		NextBlockSequencer: nextSeq,
 	}
-	return nil
+	return errorsmod.Wrap(types.CheckCompatibility(*consState, rollappState), "check compatibility")
 }

x/lightclient/keeper/client_store.go

@@ -9,6 +9,21 @@ import (
 	ibctm "github.com/cosmos/ibc-go/v7/modules/light-clients/07-tendermint"
 )
 
+// IterateConsensusStateDescending iterates through all consensus states in descending order
+// until cb returns true.
+func IterateConsensusStateDescending(clientStore sdk.KVStore, cb func(height exported.Height) (stop bool)) {
+	iterator := sdk.KVStoreReversePrefixIterator(clientStore, []byte(ibctm.KeyIterateConsensusStatePrefix))
+	defer iterator.Close() // nolint: errcheck
+
+	for ; iterator.Valid(); iterator.Next() {
+		iterKey := iterator.Key()
+		height := ibctm.GetHeightFromIterationKey(iterKey)
+		if cb(height) {
+			break
+		}
+	}
+}
+
 // functions here copied from ibc-go/modules/core/02-client/keeper/
 // as we need direct access to the client store