v2 genesis

.vscode/launch.json

@@ -19,6 +19,16 @@
       "mode": "debug",
       "program": "simapp/v2/simdv2",
       "args": ["start"],
+      // "args": ["genesis", "add-genesis-account", "cosmos130ch823d2pwh9wpfm335plg6ktatzw7j427qgs", "1000000000stake"],
+    },
+    {
+      "name": "simapp v1",
+      "type": "go",
+      "request": "launch",
+      "mode": "debug",
+      "program": "simapp/simd",
+      //"args": ["start"],
+      "args": ["genesis", "add-genesis-account", "cosmos1r8prwezs37hvxq4kc520pfhg67lgz42m4mdvrf", "1000000000stake"],
     }
   ]
 }

core/app/identity.go

@@ -1,4 +1,6 @@
 package app
 
-var RuntimeIdentity = []byte("runtime")
-var ConsensusIdentity = []byte("consensus")
+var (
+	RuntimeIdentity   = []byte("runtime")
+	ConsensusIdentity = []byte("consensus")
+)

core/appmodule/v2/genesis.go

@@ -15,3 +15,7 @@ type HasGenesis interface {
 	InitGenesis(ctx context.Context, data json.RawMessage) error
 	ExportGenesis(ctx context.Context) (json.RawMessage, error)
 }
+
+type HasABCIGenesis interface {
+	InitGenesis(ctx context.Context, data json.RawMessage) ([]ValidatorUpdate, error)
+}

core/context/context.go

@@ -12,3 +12,9 @@ const (
 	ExecModeSimulate
 	ExecModeFinalize
 )
+
+// TODO: remove
+type ContextKey string
+
+// TODO: remove
+const CometInfoKey ContextKey = "comet-info"

core/transaction/transaction.go

@@ -14,6 +14,7 @@ type Codec[T Tx] interface {
 	// Decode decodes the tx bytes into a DecodedTx, containing
 	// both concrete and bytes representation of the tx.
 	Decode([]byte) (T, error)
+	DecodeJSON([]byte) (T, error)
 }
 
 type Tx interface {

runtime/v2/builder.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 
 	appmodulev2 "cosmossdk.io/core/appmodule/v2"
 	"cosmossdk.io/core/store"
@@ -120,6 +121,21 @@ func (a *AppBuilder) Build(opts ...AppBuilderOption) (*App, error) {
 		ValidateTxGasLimit: a.app.config.GasConfig.ValidateTxGasLimit,
 		QueryGasLimit:      a.app.config.GasConfig.QueryGasLimit,
 		SimulationGasLimit: a.app.config.GasConfig.SimulationGasLimit,
+		InitGenesis: func(ctx context.Context, src io.Reader, txHandler func(json.RawMessage) error) error {
+			// this implementation assumes that the state is a JSON object
+			bz, err := io.ReadAll(src)
+			if err != nil {
+				return fmt.Errorf("failed to read import state: %w", err)
+			}
+			var genesisState map[string]json.RawMessage
+			if err = json.Unmarshal(bz, &genesisState); err != nil {
+				return err
+			}
+			if err = a.app.moduleManager.InitGenesisJSON(ctx, genesisState, txHandler); err != nil {
+				return fmt.Errorf("failed to init genesis: %w", err)
+			}
+			return nil
+		},
 	}
 
 	appManager, err := appManagerBuilder.Build()

runtime/v2/go.mod

@@ -57,6 +57,8 @@ require (
 	cosmossdk.io/errors v1.0.1 // indirect
 	cosmossdk.io/math v1.3.0 // indirect
 	cosmossdk.io/x/auth v0.0.0-00010101000000-000000000000 // indirect
+	cosmossdk.io/x/bank v0.0.0-00010101000000-000000000000 // indirect
+	cosmossdk.io/x/staking v0.0.0-00010101000000-000000000000 // indirect
 	filippo.io/edwards25519 v1.1.0 // indirect
 	github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4 // indirect
 	github.com/99designs/keyring v1.2.2 // indirect

runtime/v2/manager.go

@@ -7,6 +7,8 @@
 	"fmt"
 	"sort"
 
+	"cosmossdk.io/core/genesis"
+
 	"github.com/golang/protobuf/proto"
 	"golang.org/x/exp/maps"
 	"google.golang.org/grpc"
@@ -26,6 +28,7 @@
 
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdkmodule "github.com/cosmos/cosmos-sdk/types/module"
+	"github.com/cosmos/cosmos-sdk/x/genutil/types"
 )
 
 type MM struct {
@@ -140,9 +143,68 @@
 	return nil
 }
 
-// InitGenesis performs init genesis functionality for modules.
-func (m *MM) InitGenesis() {
-	panic("implement me")
+// InitGenesisJSON performs init genesis functionality for modules from genesis data in JSON format
+func (m *MM) InitGenesisJSON(ctx context.Context, genesisData map[string]json.RawMessage, txHandler func(json.RawMessage) error) error {
+	m.logger.Info("initializing blockchain state from genesis.json", "order", m.config.InitGenesis)
+	var seenValUpdates bool
+	for _, moduleName := range m.config.InitGenesis {
+		if genesisData[moduleName] == nil {
+			continue
+		}
+
+		mod := m.modules[moduleName]
+
+		// skip genutil as it's a special module that handles gentxs
+		// TODO: should this be an empty extension interface on genutil for server v2?
+		if moduleName == "genutil" {
+			var genesisState types.GenesisState
+			err := m.cdc.UnmarshalJSON(genesisData[moduleName], &genesisState)
+			if err != nil {
+				return fmt.Errorf("failed to unmarshal %s genesis state: %w", moduleName, err)
+			}
+			for _, jsonTx := range genesisState.GenTxs {
+				txHandler(jsonTx)
+			}
+			continue
+		}
+
+		// we might get an adapted module, a native core API module or a legacy module
+		if module, ok := mod.(appmodule.HasGenesisAuto); ok {
+			m.logger.Debug("running initialization for module", "module", moduleName)
+			// core API genesis
+			source, err := genesis.SourceFromRawJSON(genesisData[moduleName])
+			if err != nil {
+				return err
+			}
+
+			err = module.InitGenesis(ctx, source)
+			if err != nil {
+				return err
+			}
+		} else if module, ok := mod.(appmodulev2.HasGenesis); ok {
+			m.logger.Debug("running initialization for module", "module", moduleName)
+			if err := module.InitGenesis(ctx, genesisData[moduleName]); err != nil {
+				return err
+			}
+		} else if module, ok := mod.(appmodulev2.HasABCIGenesis); ok {
+			m.logger.Debug("running initialization for module", "module", moduleName)
+			moduleValUpdates, err := module.InitGenesis(ctx, genesisData[moduleName])
+			if err != nil {
+				return err
+			}
+
+			// use these validator updates if provided, the module manager assumes
+			// only one module will update the validator set
+			if len(moduleValUpdates) > 0 {
+				if seenValUpdates {
+					return errors.New("validator InitGenesis updates already set by a previous module")
+				} else {
+					seenValUpdates = true
+				}
+			}
+		}
+	}
+	return nil
 }
 
 // ExportGenesis performs export genesis functionality for modules

runtime/v2/module.go

@@ -114,6 +114,7 @@ func init() {
 			ProvideGenesisTxHandler,
 			ProvideAppVersionModifier,
 		),
+		appconfig.Invoke(SetupAppBuilder),
 	)
 }
 
@@ -166,7 +167,7 @@ type AppInputs struct {
 	InterfaceRegistry codectypes.InterfaceRegistry
 	LegacyAmino       *codec.LegacyAmino
 	Logger            log.Logger
-	StoreOptions      *rootstorev2.FactoryOptions
+	StoreOptions      *rootstorev2.FactoryOptions `optional:"true"`
 }
 
 func SetupAppBuilder(inputs AppInputs) {
@@ -178,11 +179,13 @@ func SetupAppBuilder(inputs AppInputs) {
 	app.moduleManager.RegisterInterfaces(inputs.InterfaceRegistry)
 	app.moduleManager.RegisterLegacyAminoCodec(inputs.LegacyAmino)
 
-	// TODO: this is a bit of a hack, but it's the only way to get the store keys into the app
-	// registerStoreKey could instead set this on StoreOptions directly
-	inputs.AppBuilder.storeOptions = inputs.StoreOptions
-	for _, sk := range inputs.AppBuilder.app.storeKeys {
-		inputs.AppBuilder.storeOptions.StoreKeys = append(inputs.AppBuilder.storeOptions.StoreKeys, sk.String())
+	if inputs.StoreOptions != nil {
+		// TODO: this is a bit of a hack, but it's the only way to get the store keys into the app
+		// registerStoreKey could instead set this on StoreOptions directly
+		inputs.AppBuilder.storeOptions = inputs.StoreOptions
+		for _, sk := range inputs.AppBuilder.app.storeKeys {
+			inputs.AppBuilder.storeOptions.StoreKeys = append(inputs.AppBuilder.storeOptions.StoreKeys, sk.String())
+		}
 	}
 }
 

server/v2/appmanager/appmanager.go

@@ -1,7 +1,9 @@
 package appmanager
 
 import (
+	"bytes"
 	"context"
+	"encoding/json"
 	"fmt"
 	"io"
 
@@ -22,6 +24,8 @@ type AppManager[T transaction.Tx] struct {
 	exportState func(ctx context.Context, dst map[string]io.Writer) error
 	importState func(ctx context.Context, src map[string]io.Reader) error
 
+	initGenesis func(ctx context.Context, state io.Reader, txHandler func(tx json.RawMessage) error) error
+
 	stf *stf.STF[T]
 }
 
@@ -30,30 +34,50 @@ func (a AppManager[T]) InitGenesis(
 	headerInfo header.Info,
 	consensusMessages []transaction.Type,
 	initGenesisJSON []byte,
-) (corestore.WriterMap, error) {
+	txDecoder transaction.Codec[T],
+) (*appmanager.BlockResponse, corestore.WriterMap, error) {
+	v, zeroState, err := a.db.StateLatest()
+	if err != nil {
+		return nil, nil, fmt.Errorf("unable to get latest state: %w", err)
+	}
+	if v != 0 {
+		return nil, nil, fmt.Errorf("cannot init genesis on non-zero state")
+	}
+
+	var genTxs []T
+	zeroState, err = a.stf.RunWithCtx(ctx, zeroState, func(ctx context.Context) error {
+		return a.initGenesis(ctx, bytes.NewBuffer(initGenesisJSON), func(jsonTx json.RawMessage) error {
+			genTx, err := txDecoder.DecodeJSON(jsonTx)
+			if err != nil {
+				return fmt.Errorf("failed to decode genesis transaction: %w", err)
+			}
+			genTxs = append(genTxs, genTx)
+			return nil
+		})
+	})
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to import genesis state: %w", err)
+	}
 	// run block 0
 	// TODO: in an ideal world, genesis state is simply an initial state being applied
 	// unaware of what that state means in relation to every other, so here we can
 	// chain genesis
 	block0 := &appmanager.BlockRequest[T]{
-		Height:            uint64(headerInfo.Height),
+		Height:            uint64(0),
 		Time:              headerInfo.Time,
 		Hash:              headerInfo.Hash,
 		ChainId:           headerInfo.ChainID,
 		AppHash:           headerInfo.AppHash,
-		Txs:               nil,
+		Txs:               genTxs,
 		ConsensusMessages: consensusMessages,
 	}
 
-	_, genesisState, err := a.DeliverBlock(ctx, block0)
+	blockresponse, genesisState, err := a.stf.DeliverBlock(ctx, block0, zeroState)
 	if err != nil {
-		return nil, err
+		return blockresponse, nil, fmt.Errorf("failed to deliver block 0: %w", err)
 	}
 
-	// TODO: ok so the problem we have now, the genesis is a mix of initial state
-	// then followed by txs from the genutil module.
-
-	return genesisState, nil
+	return blockresponse, genesisState, err
 }
 
 func (a AppManager[T]) DeliverBlock(

server/v2/appmanager/appmanager_builder.go

@@ -1,6 +1,10 @@
 package appmanager
 
 import (
+	"context"
+	"encoding/json"
+	"io"
+
 	"cosmossdk.io/core/transaction"
 	"cosmossdk.io/server/v2/appmanager/store"
 	"cosmossdk.io/server/v2/stf"
@@ -12,6 +16,8 @@ type Builder[T transaction.Tx] struct {
 	ValidateTxGasLimit,
 	QueryGasLimit,
 	SimulationGasLimit uint64
+
+	InitGenesis func(ctx context.Context, src io.Reader, txHandler func(json.RawMessage) error) error
 }
 
 func (b Builder[T]) Build() (*AppManager[T], error) {
@@ -24,6 +30,7 @@ func (b Builder[T]) Build() (*AppManager[T], error) {
 		db:          b.DB,
 		exportState: nil,
 		importState: nil,
+		initGenesis: b.InitGenesis,
 		stf:         b.STF,
 	}, nil
 }