feat(rollapp): Updating x/rollapp to accommodate generalized DA layer interface

app/app.go

@@ -41,7 +41,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/server/config"
 	servertypes "github.com/cosmos/cosmos-sdk/server/types"
 	"github.com/cosmos/cosmos-sdk/store/streaming"
-
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/module"
 	moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil"

proto/dymensionxyz/dymension/rollapp/rollapp.proto

@@ -2,6 +2,7 @@ syntax = "proto3";
 package dymensionxyz.dymension.rollapp;
 
 option go_package = "github.com/dymensionxyz/dymension/v3/x/rollapp/types";
+import "google/protobuf/any.proto";
 
 import "gogoproto/gogo.proto";
 import "cosmos/base/v1beta1/coin.proto";
@@ -67,3 +68,10 @@ message RollappSummary {
   StateInfoIndex latestFinalizedStateIndex = 3;
 }
 
+// DAPath defines the location on the DA layer where the blob is posted.
+message DAPath {
+  // daType identifies the DA type being used by the sequencer to post the blob.
+  string daType = 1;
+  // commitment defines a generic commitment interpreted by the DA Layer.
+  google.protobuf.Any commitment = 2;
+}

proto/dymensionxyz/dymension/rollapp/v2/tx.proto

@@ -0,0 +1,40 @@
+syntax = "proto3";
+package dymensionxyz.dymension.rollapp.v2;
+
+// this line is used by starport scaffolding # proto/tx/import
+import "cosmos/msg/v1/msg.proto";
+import "dymensionxyz/dymension/rollapp/block_descriptor.proto";
+import "dymensionxyz/dymension/rollapp/rollapp.proto";
+
+option go_package = "github.com/dymensionxyz/dymension/v3/x/rollapp/types/v2";
+
+import "gogoproto/gogo.proto";
+
+// Msg defines the Msg service.
+service Msg {
+  rpc UpdateState(MsgUpdateState) returns (MsgUpdateStateResponse);
+}
+
+
+// MsgUpdateState updates a rollapp state with a block batch.
+// a block batch is a list of ordered blocks (by height)
+message MsgUpdateState {
+  option (cosmos.msg.v1.signer) = "creator";
+  // creator is the bech32-encoded address of the sequencer sending the update
+  string creator = 1;
+  // rollappId is the rollapp that the sequencer belongs to and asking to update
+  // The rollappId follows the same standard as cosmos chain_id
+  string rollappId = 2;
+  // startHeight is the block height of the first block in the batch
+  uint64 startHeight = 3;
+  // numBlocks is the number of blocks included in this batch update
+  uint64 numBlocks = 4;
+  // DAPath is the description of the location on the DA layer
+  DAPath DAPath = 5;
+  // BDs is a list of block description objects (one per block)
+  // the list must be ordered by height, starting from startHeight to startHeight+numBlocks-1
+  BlockDescriptors BDs = 6 [(gogoproto.nullable) = false];
+}
+
+message MsgUpdateStateResponse {
+}

x/delayedack/keeper/hooks_test.go

@@ -2,7 +2,6 @@ package keeper_test
 
 import (
 	channeltypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types"
-
 	commontypes "github.com/dymensionxyz/dymension/v3/x/common/types"
 	"github.com/dymensionxyz/dymension/v3/x/delayedack/types"
 )

x/rollapp/keeper/invariants_test.go

@@ -2,7 +2,6 @@ package keeper_test
 
 import (
 	"github.com/cometbft/cometbft/libs/rand"
-
 	commontypes "github.com/dymensionxyz/dymension/v3/x/common/types"
 	"github.com/dymensionxyz/dymension/v3/x/rollapp/keeper"
 	"github.com/dymensionxyz/dymension/v3/x/rollapp/types"

x/rollapp/keeper/keeper.go

@@ -23,6 +23,8 @@ type Keeper struct {
 	channelKeeper   types.ChannelKeeper
 	bankKeeper      types.BankKeeper
 
+	daLayers map[string]types.DALayer
+
 	finalizePending func(ctx sdk.Context, stateInfoIndex types.StateInfoIndex) error
 }
 
@@ -39,6 +41,9 @@ func NewKeeper(
 		ps = ps.WithKeyTable(types.ParamKeyTable())
 	}
 
+	daLayers := make(map[string]types.DALayer)
+	daLayers[types.InterchainDALayerName] = types.NewInterchainDALayer()
+
 	k := &Keeper{
 		cdc:             cdc,
 		storeKey:        storeKey,
@@ -47,6 +52,7 @@ func NewKeeper(
 		channelKeeper:   channelKeeper,
 		ibcClientKeeper: ibcclientKeeper,
 		bankKeeper:      bankKeeper,
+		daLayers:        daLayers,
 	}
 	k.SetFinalizePendingFn(k.finalizePendingState)
 	return k

x/rollapp/keeper/msg_server.go

@@ -2,16 +2,30 @@ package keeper
 
 import (
 	"github.com/dymensionxyz/dymension/v3/x/rollapp/types"
+	v2types "github.com/dymensionxyz/dymension/v3/x/rollapp/types/v2"
 )
 
 type msgServer struct {
 	Keeper
 }
 
+type msgServerV2 struct {
+	Keeper
+}
+
+var (
+	_ types.MsgServer   = msgServer{}
+	_ v2types.MsgServer = msgServerV2{}
+)
+
 // NewMsgServerImpl returns an implementation of the MsgServer interface
 // for the provided Keeper.
 func NewMsgServerImpl(keeper Keeper) types.MsgServer {
 	return &msgServer{Keeper: keeper}
 }
 
-var _ types.MsgServer = msgServer{}
+// NewMsgServerV2Impl returns an implementation of the MsgServer interface
+// for the provided Keeper.
+func NewMsgServerV2Impl(keeper Keeper) v2types.MsgServer {
+	return &msgServerV2{Keeper: keeper}
+}

x/rollapp/keeper/msg_server_update_state_v2.go

@@ -0,0 +1,108 @@
+package keeper
+
+import (
+	"context"
+
+	errorsmod "cosmossdk.io/errors"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/dymensionxyz/dymension/v3/x/rollapp/types"
+	v2types "github.com/dymensionxyz/dymension/v3/x/rollapp/types/v2"
+)
+
+// UpdateState updates the state of a rollapp
+func (k msgServerV2) UpdateState(goCtx context.Context, msg *v2types.MsgUpdateState) (*v2types.MsgUpdateStateResponse, error) {
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	// load rollapp object for stateful validations
+	_, isFound := k.GetRollapp(ctx, msg.RollappId)
+	if !isFound {
+		return nil, types.ErrUnknownRollappID
+	}
+
+	// call the before-update-state hook
+	// checks if:
+	// 	1. creator is the sequencer
+	// 	2. sequencer rollappId matches the rollappId
+	// 	3. sequencer is bonded
+	// 	4. sequencer is the proposer
+	err := k.hooks.BeforeUpdateState(ctx, msg.Creator, msg.RollappId)
+	if err != nil {
+		return nil, err
+	}
+
+	// retrieve last updating index
+	var newIndex, lastIndex uint64
+	latestStateInfoIndex, found := k.GetLatestStateInfoIndex(ctx, msg.RollappId)
+	if found {
+		// retrieve last updating index
+		stateInfo, found := k.GetStateInfo(ctx, msg.RollappId, latestStateInfoIndex.Index)
+		// if latestStateInfoIndex exists, there must be an info for this state
+		if !found {
+			// if not, it's a logic error
+			return nil, errorsmod.Wrapf(types.ErrLogic,
+				"missing stateInfo for state-index (%d) of rollappId(%s)",
+				latestStateInfoIndex.Index, msg.RollappId)
+		}
+
+		// check to see if received height is the one we expected
+		expectedStartHeight := stateInfo.StartHeight + stateInfo.NumBlocks
+		if expectedStartHeight != msg.StartHeight {
+			return nil, errorsmod.Wrapf(types.ErrWrongBlockHeight,
+				"expected height (%d), but received (%d)",
+				expectedStartHeight, msg.StartHeight)
+		}
+
+		// bump state index
+		lastIndex = latestStateInfoIndex.Index
+	}
+	newIndex = lastIndex + 1
+
+	daLayer, exists := k.daLayers[msg.DAPath.DaType]
+	if !exists {
+		return nil, errorsmod.Wrapf(types.ErrInvalidDAClientType, "unknown da layer: %s", msg.DAPath.DaType)
+	}
+	if err = daLayer.OnRollappStateUpdate(ctx, msg.DAPath.Commitment); err != nil {
+		return nil, errorsmod.Wrapf(types.ErrDAClientValidationFailed, "da layer commitment validation failed: %s", err)
+	}
+
+	// Write new index information to the store
+	k.SetLatestStateInfoIndex(ctx, types.StateInfoIndex{
+		RollappId: msg.RollappId,
+		Index:     newIndex,
+	})
+
+	creationHeight := uint64(ctx.BlockHeight())
+	daPath, err := msg.DAPath.Marshal()
+	if err != nil {
+		return nil, errorsmod.Wrapf(types.ErrInvalidDAClientType, "failed to marshal DAPath: %s", err)
+	}
+	stateInfo := types.NewStateInfo(msg.RollappId, newIndex, msg.Creator, msg.StartHeight, msg.NumBlocks, string(daPath), creationHeight, msg.BDs)
+	// Write new state information to the store indexed by <RollappId,LatestStateInfoIndex>
+	k.SetStateInfo(ctx, *stateInfo)
+
+	stateInfoIndex := stateInfo.GetIndex()
+	newFinalizationQueue := []types.StateInfoIndex{stateInfoIndex}
+
+	k.Logger(ctx).Debug("Adding state to finalization queue at ", creationHeight)
+	// load FinalizationQueue and update
+	blockHeightToFinalizationQueue, found := k.GetBlockHeightToFinalizationQueue(ctx, creationHeight)
+	if found {
+		newFinalizationQueue = append(blockHeightToFinalizationQueue.FinalizationQueue, newFinalizationQueue...)
+	}
+
+	// Write new BlockHeightToFinalizationQueue
+	k.SetBlockHeightToFinalizationQueue(ctx, types.BlockHeightToFinalizationQueue{
+		CreationHeight:    creationHeight,
+		FinalizationQueue: newFinalizationQueue,
+	})
+
+	ctx.EventManager().EmitEvent(
+		sdk.NewEvent(types.EventTypeStateUpdate,
+			stateInfo.GetEvents()...,
+		),
+	)
+
+	return &v2types.MsgUpdateStateResponse{}, nil
+}