feat(hard-fork): Implement rollapp hard fork

app/keepers/keepers.go

@@ -475,6 +475,7 @@ func (a *AppKeepers) InitKeepers(
 	a.DelayedAckKeeper = *delayedackkeeper.NewKeeper(
 		appCodec,
 		a.keys[delayedacktypes.StoreKey],
+		a.keys[ibcexported.StoreKey],
 		a.GetSubspace(delayedacktypes.ModuleName),
 		a.RollappKeeper,
 		a.IBCKeeper.ChannelKeeper,

app/upgrades/v4/upgrade.go

@@ -221,7 +221,6 @@ func ConvertOldRollappToNew(oldRollapp rollapptypes.Rollapp) rollapptypes.Rollap
 		Owner:        oldRollapp.Owner,
 		GenesisState: oldRollapp.GenesisState,
 		ChannelId:    oldRollapp.ChannelId,
-		Frozen:       oldRollapp.Frozen,
 		// TODO: regarding missing data - https://github.com/dymensionxyz/dymension/issues/986
 		VmType: rollapptypes.Rollapp_EVM, // placeholder data
 		Metadata: &rollapptypes.RollappMetadata{
@@ -248,6 +247,7 @@ func ConvertOldRollappToNew(oldRollapp rollapptypes.Rollapp) rollapptypes.Rollap
 		},
 		InitialSequencer: "*",
 		Launched:         true,
+		RevisionNumber:   0,
 	}
 }
 

ibctesting/delayed_ack_test.go

@@ -235,3 +235,5 @@ func (s *delayedAckSuite) TestHubToRollappTimeout() {
 	postFinalizeBalance := bankKeeper.GetBalance(s.hubCtx(), senderAccount, sdk.DefaultBondDenom)
 	s.Require().Equal(preSendBalance.Amount, postFinalizeBalance.Amount)
 }
+
+// FIXME: test refunds due to hard fork + receipt deletion

ibctesting/light_client_test.go

@@ -6,6 +6,7 @@ import (
 	errorsmod "cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	clienttypes "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/cosmos/ibc-go/v7/testing/simapp"
 
 	"github.com/dymensionxyz/dymension/v3/x/lightclient/types"
@@ -342,10 +343,137 @@ func (s *lightClientSuite) TestAfterUpdateState_OptimisticUpdateExists_NotCompat
 	)
 	_, err = s.rollappMsgServer().UpdateState(s.hubCtx(), msgUpdateState)
 	s.Error(err)
+
+	// Assert that hard fork was triggered
+	rollapp, _ := s.hubApp().RollappKeeper.GetRollapp(s.hubCtx(), s.rollappChain().ChainID)
+	s.Equal(uint64(1), rollapp.RevisionNumber)
+
 	// The optimistic update valhash should be removed as part of fraud handling
 	_, found = s.hubApp().LightClientKeeper.GetConsensusStateValHash(s.hubCtx(), s.path.EndpointA.ClientID, uint64(header.Header.Height))
 	s.False(found)
-	// Ensuring that the rollapp is now frozen as part of fraud handling
-	rollapp, _ := s.hubApp().RollappKeeper.GetRollapp(s.hubCtx(), s.rollappChain().ChainID)
-	s.True(rollapp.Frozen)
+}
+
+// Test the rollback flow for a light client
+// - do some client updates
+// - trigger rollback
+// - validate rollback:
+//   - check if the client is frozen
+//   - validate IsHardForkingInProgress returns true
+//   - validate client updates are blocked
+//   - validate future consensus states are cleared
+//
+// - resolve hard fork
+//   - validate client is unfrozen and hard fork is resolved
+//   - validate the client is updated
+//   - validate the client is not in hard forking state
+//
+// - validate client updates are allowed
+func (s *lightClientSuite) TestAfterUpdateState_Rollback() {
+	s.createRollapp(false, nil)
+	s.registerSequencer()
+	s.path = s.newTransferPath(s.hubChain(), s.rollappChain())
+	s.coordinator.SetupConnections(s.path)
+	s.hubApp().LightClientKeeper.SetCanonicalClient(s.hubCtx(), s.rollappChain().ChainID, s.path.EndpointA.ClientID)
+	s.coordinator.CreateChannels(s.path)
+
+	bds := rollapptypes.BlockDescriptors{}
+
+	for i := 0; i < 20; i++ {
+		s.coordinator.CommitBlock(s.hubChain(), s.rollappChain())
+
+		lastHeader := s.rollappChain().LastHeader
+		bd := rollapptypes.BlockDescriptor{Height: uint64(lastHeader.Header.Height), StateRoot: lastHeader.Header.AppHash, Timestamp: lastHeader.Header.Time}
+		bds.BD = append(bds.BD, bd)
+
+		if i%5 == 0 {
+			header, err := s.path.EndpointA.Chain.ConstructUpdateTMClientHeader(s.path.EndpointA.Counterparty.Chain, s.path.EndpointA.ClientID)
+			s.NoError(err)
+			msg, err := clienttypes.NewMsgUpdateClient(
+				s.path.EndpointA.ClientID, header,
+				s.path.EndpointA.Chain.SenderAccount.GetAddress().String(),
+			)
+			s.NoError(err)
+			_, err = s.path.EndpointA.Chain.SendMsgs(msg)
+			s.NoError(err)
+		}
+
+	}
+
+	// get number of consensus states before rollback
+	csBeforeRollback := s.hubApp().IBCKeeper.ClientKeeper.GetAllConsensusStates(s.hubCtx())[0].ConsensusStates
+
+	// Trigger rollback
+	rollbackHeight := uint64(s.rollappChain().LastHeader.Header.Height) - 5
+	s.hubApp().LightClientKeeper.RollbackCanonicalClient(s.hubCtx(), s.rollappChain().ChainID, rollbackHeight)
+
+	clientState, found := s.hubApp().IBCKeeper.ClientKeeper.GetClientState(s.hubCtx(), s.path.EndpointA.ClientID)
+	s.True(found)
+	tmClientState, ok := clientState.(*ibctm.ClientState)
+	s.True(ok)
+
+	// Check if the client is frozen
+	s.True(!tmClientState.FrozenHeight.IsZero(), "Client should be frozen after rollback")
+
+	// Check if IsHardForkingInProgress returns true
+	s.True(s.hubApp().LightClientKeeper.IsHardForkingInProgress(s.hubCtx(), s.rollappChain().ChainID), "Rollapp should be in hard forking state")
+
+	// Validate future consensus states are cleared
+	csAfterRollback := s.hubApp().IBCKeeper.ClientKeeper.GetAllConsensusStates(s.hubCtx())[0].ConsensusStates
+	s.Require().Less(len(csAfterRollback), len(csBeforeRollback), "Consensus states should be cleared after rollback")
+	for height := uint64(0); height <= uint64(s.rollappChain().LastHeader.Header.Height); height++ {
+		_, found := s.hubApp().IBCKeeper.ClientKeeper.GetClientConsensusState(s.hubCtx(), s.path.EndpointA.ClientID, clienttypes.NewHeight(1, height))
+		if height > rollbackHeight {
+			s.False(found, "Consensus state should be cleared for height %d", height)
+		}
+	}
+
+	// Validate client updates are blocked
+	header, err := s.path.EndpointA.Chain.ConstructUpdateTMClientHeader(s.path.EndpointA.Counterparty.Chain, s.path.EndpointA.ClientID)
+	s.NoError(err)
+	msg, err := clienttypes.NewMsgUpdateClient(
+		s.path.EndpointA.ClientID, header,
+		s.path.EndpointA.Chain.SenderAccount.GetAddress().String(),
+	)
+	s.NoError(err)
+	_, _, err = simapp.SignAndDeliver(
+		s.path.EndpointA.Chain.T,
+		s.path.EndpointA.Chain.TxConfig,
+		s.path.EndpointA.Chain.App.GetBaseApp(),
+		s.path.EndpointA.Chain.GetContext().BlockHeader(),
+		[]sdk.Msg{msg},
+		s.path.EndpointA.Chain.ChainID,
+		[]uint64{s.path.EndpointA.Chain.SenderAccount.GetAccountNumber()},
+		[]uint64{s.path.EndpointA.Chain.SenderAccount.GetSequence()},
+		true, false, s.path.EndpointA.Chain.SenderPrivKey,
+	)
+	s.ErrorIs(err, types.ErrorHardForkInProgress)
+
+	// submit a state info update to resolve the hard fork
+	blockDescriptors := &rollapptypes.BlockDescriptors{BD: bds.BD}
+	msgUpdateState := rollapptypes.NewMsgUpdateState(
+		s.hubChain().SenderAccount.GetAddress().String(),
+		rollappChainID(),
+		"mock-da-path",
+		bds.BD[0].Height,
+		uint64(len(bds.BD)),
+		blockDescriptors,
+	)
+	_, err = s.rollappMsgServer().UpdateState(s.hubCtx(), msgUpdateState)
+	s.Require().NoError(err)
+
+	// Test resolve hard fork
+	clientState, found = s.hubApp().IBCKeeper.ClientKeeper.GetClientState(s.hubCtx(), s.path.EndpointA.ClientID)
+	s.True(found)
+	// Verify that the client is unfrozen and hard fork is resolved
+	s.True(clientState.(*ibctm.ClientState).FrozenHeight.IsZero(), "Client should be unfrozen after hard fork resolution")
+	// Verify that the client is not in hard forking state
+	s.False(s.hubApp().LightClientKeeper.IsHardForkingInProgress(s.hubCtx(), s.rollappChain().ChainID), "Rollapp should not be in hard forking state")
+	// Verify that the client is updated with the height of the last block descriptor
+	s.Require().Equal(bds.BD[len(bds.BD)-1].Height, clientState.GetLatestHeight().GetRevisionHeight())
+	_, ok = s.hubApp().IBCKeeper.ClientKeeper.GetLatestClientConsensusState(s.hubCtx(), s.path.EndpointA.ClientID)
+	s.True(ok)
+
+	// validate client updates are no longer blocked
+	s.coordinator.CommitBlock(s.rollappChain())
+	s.NoError(s.path.EndpointA.UpdateClient())
 }

proto/dymensionxyz/dymension/common/status.proto

@@ -8,5 +8,4 @@ option go_package = "github.com/dymensionxyz/dymension/v3/x/common/types";
 enum Status {
     PENDING = 0;
     FINALIZED = 1;
-    REVERTED = 3;
 }

proto/dymensionxyz/dymension/rollapp/genesis.proto

@@ -26,5 +26,5 @@ message GenesisState {
 
 message RollappRegisteredDenoms {
   string rollapp_id = 1;
-  repeated string denoms = 2 [(gogoproto.nullable) = false];
+  repeated string denoms = 2;
 }

proto/dymensionxyz/dymension/rollapp/rollapp.proto

@@ -41,10 +41,10 @@ message Rollapp {
   RollappGenesisState genesis_state = 7 [ (gogoproto.nullable) = false ];
   // channel_id will be set to the canonical IBC channel of the rollapp.
   string channel_id = 8;
-  // frozen is a boolean that indicates if the rollapp is frozen.
-  bool frozen = 9;
 
+  reserved 9;
   reserved 10;
+
   // metadata is the rollapp metadata
   RollappMetadata metadata = 11;
   // genesis_info keeps immutable rollapp fields
@@ -75,6 +75,9 @@ message Rollapp {
   // The LastStateUpdateHeight HUB height when the last state update was
   // received
   int64 last_state_update_height = 18;
+
+  // The revision number of the rollapp. starts always with 0 revision
+  uint64 revision_number = 19;
 }
 
 // Rollapp summary is a compact representation of Rollapp

proto/dymensionxyz/dymension/rollapp/tx.proto

@@ -89,6 +89,8 @@ message MsgUpdateState {
   BlockDescriptors BDs = 7 [(gogoproto.nullable) = false];
   // last is true if this is the last batch of the sequencer
   bool last = 8;
+  // rollapp_revision is the revision of the rollapp chain
+  uint64 rollapp_revision = 9;
 }
 
 message MsgUpdateStateResponse {

testutil/keeper/delayedack.go

@@ -28,6 +28,11 @@ import (
 
 type ChannelKeeperStub struct{}
 
+// SetPacketReceipt implements types.ChannelKeeper.
+func (c ChannelKeeperStub) SetPacketReceipt(ctx sdk.Context, portID string, channelID string, sequence uint64) {
+	return
+}
+
 func (ChannelKeeperStub) LookupModuleByChannel(ctx sdk.Context, portID, channelID string) (string, *capabilitytypes.Capability, error) {
 	return "", nil, nil
 }
@@ -137,6 +142,7 @@ func DelayedackKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) {
 
 	k := keeper.NewKeeper(cdc,
 		storeKey,
+		nil,
 		paramsSubspace,
 		RollappKeeperStub{},
 		ICS4WrapperStub{},

testutil/keeper/lightclient.go

@@ -95,6 +95,11 @@ type MockIBCCLientKeeper struct {
 	clientStates         map[string]exported.ClientState
 }
 
+// ClientStore implements types.IBCClientKeeperExpected.
+func (m *MockIBCCLientKeeper) ClientStore(ctx sdk.Context, clientID string) storetypes.KVStore {
+	panic("unimplemented")
+}
+
 func NewMockIBCClientKeeper(
 	clientCS map[string]map[uint64]exported.ConsensusState,
 	genesisClients map[string]exported.ClientState,
@@ -136,6 +141,11 @@ type MockSequencerKeeper struct {
 	sequencers map[string]sequencertypes.Sequencer
 }
 
+// GetProposer implements types.SequencerKeeperExpected.
+func (m *MockSequencerKeeper) GetProposer(ctx sdk.Context, rollappId string) (val sequencertypes.Sequencer, found bool) {
+	panic("unimplemented")
+}
+
 func (m *MockSequencerKeeper) UnbondingTime(ctx sdk.Context) (res time.Duration) {
 	return types.DefaultExpectedCanonicalClientParams().UnbondingPeriod
 }
@@ -159,8 +169,17 @@ func (m *MockSequencerKeeper) GetSequencersByRollapp(ctx sdk.Context, rollappId
 	return seqs
 }
 
+func (m *MockSequencerKeeper) JailSequencerOnFraud(ctx sdk.Context, seqAddr string) error {
+	return nil
+}
+
 type MockRollappKeeper struct{}
 
+// GetLatestStateInfo implements types.RollappKeeperExpected.
+func (m *MockRollappKeeper) GetLatestStateInfo(ctx sdk.Context, rollappId string) (rollapptypes.StateInfo, bool) {
+	panic("unimplemented")
+}
+
 func NewMockRollappKeeper() *MockRollappKeeper {
 	return &MockRollappKeeper{}
 }
@@ -180,6 +199,6 @@ func (m *MockRollappKeeper) GetStateInfo(ctx sdk.Context, rollappId string, inde
 func (m *MockRollappKeeper) SetRollapp(ctx sdk.Context, rollapp rollapptypes.Rollapp) {
 }
 
-func (m *MockRollappKeeper) HandleFraud(ctx sdk.Context, rollappID, clientId string, fraudHeight uint64, seqAddr string) error {
+func (m *MockRollappKeeper) HardFork(ctx sdk.Context, rollappID string, fraudHeight uint64) error {
 	return nil
 }

x/common/types/key_rollapp_packet.go

@@ -18,8 +18,6 @@ var (
 	PendingRollappPacketKeyPrefix = []byte{0x00, 0x01}
 	// FinalizedRollappPacketKeyPrefix is the prefix for finalized rollapp packets
 	FinalizedRollappPacketKeyPrefix = []byte{0x00, 0x02}
-	// RevertedRollappPacketKeyPrefix is the prefix for reverted rollapp packets
-	RevertedRollappPacketKeyPrefix = []byte{0x00, 0x03}
 	// keySeparatorBytes is used to separate the rollapp packet key parts
 	keySeparatorBytes = []byte("/")
 )
@@ -100,8 +98,6 @@ func MustGetStatusBytes(status Status) []byte {
 		return PendingRollappPacketKeyPrefix
 	case Status_FINALIZED:
 		return FinalizedRollappPacketKeyPrefix
-	case Status_REVERTED:
-		return RevertedRollappPacketKeyPrefix
 	default:
 		panic(fmt.Sprintf("invalid packet status: %s", status))
 	}

x/delayedack/client/cli/query.go

@@ -62,7 +62,7 @@ func CmdGetPacketsByRollapp() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "packets-by-rollapp rollapp-id [status] [type]",
 		Short: "Get packets by rollapp-id",
-		Long: `Get packets by rollapp-id. Can filter by status (pending/finalized/reverted) and by type (recv/ack/timeout)
+		Long: `Get packets by rollapp-id. Can filter by status (pending/finalized) and by type (recv/ack/timeout)
 		Example:
 		packets rollapp1
 		packets rollapp1 PENDING
@@ -124,7 +124,7 @@ func CmdGetPacketsByStatus() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "packets-by-status status [type]",
 		Short: "Get packets by status",
-		Long: `Get packets by status (pending/finalized/reverted). Can filter by type (recv/ack/timeout)
+		Long: `Get packets by status (pending/finalized). Can filter by type (recv/ack/timeout)
 		Example:
 		packets-by-status pending
 		packets-by-status finalized recv`,