@agoric/cosmos 0.34.2-dev-afe8a6e.0 → 0.34.2-dev-857e650.0

package/app/app.go

@@ -8,6 +8,7 @@ import (
 	"net/http"
 	"os"
 	"path/filepath"
+	"runtime/debug"
 	"time"
 
 	"github.com/cosmos/cosmos-sdk/baseapp"
@@ -21,6 +22,7 @@ import (
 	servertypes "github.com/cosmos/cosmos-sdk/server/types"
 	"github.com/cosmos/cosmos-sdk/simapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/errors"
 	"github.com/cosmos/cosmos-sdk/types/module"
 	"github.com/cosmos/cosmos-sdk/version"
 	"github.com/cosmos/cosmos-sdk/x/auth"
@@ -196,6 +198,7 @@ type GaiaApp struct { // nolint: golint
 	interfaceRegistry types.InterfaceRegistry
 
 	controllerInited bool
+	bootstrapNeeded  bool
 	lienPort         int
 	vbankPort        int
 	vibcPort         int
@@ -431,17 +434,20 @@ func NewAgoricApp(
 
 	// This function is tricky to get right, so we build it ourselves.
 	callToController := func(ctx sdk.Context, str string) (string, error) {
+		app.CheckControllerInited(true)
 		// We use SwingSet-level metering to charge the user for the call.
-		app.MustInitController(ctx)
 		defer vm.SetControllerContext(ctx)()
 		return sendToController(true, str)
 	}
 
+	setBootstrapNeeded := func() {
+		app.bootstrapNeeded = true
+	}
+
 	app.VstorageKeeper = vstorage.NewKeeper(
 		keys[vstorage.StoreKey],
 	)
-	vm.RegisterPortHandler("vstorage", vstorage.NewStorageHandler(app.VstorageKeeper))
-	app.vstoragePort = vm.GetPort("vstorage")
+	app.vstoragePort = vm.RegisterPortHandler("vstorage", vstorage.NewStorageHandler(app.VstorageKeeper))
 
 	// The SwingSetKeeper is the Keeper from the SwingSet module
 	app.SwingSetKeeper = swingset.NewKeeper(
@@ -453,8 +459,18 @@ func NewAgoricApp(
 
 	app.SwingSetSnapshotter = swingsetkeeper.NewSwingsetSnapshotter(
 		bApp,
-		app.SwingSetKeeper,
-		sendToController,
+		app.SwingSetKeeper.ExportSwingStore,
+		func(action vm.Jsonable, mustNotBeInited bool) (string, error) {
+			if mustNotBeInited {
+				app.CheckControllerInited(false)
+			}
+
+			bz, err := json.Marshal(action)
+			if err != nil {
+				return "", err
+			}
+			return sendToController(true, string(bz))
+		},
 	)
 
 	app.VibcKeeper = vibc.NewKeeper(
@@ -582,7 +598,7 @@ func NewAgoricApp(
 		transferModule,
 		icaModule,
 		vstorage.NewAppModule(app.VstorageKeeper),
-		swingset.NewAppModule(app.SwingSetKeeper),
+		swingset.NewAppModule(app.SwingSetKeeper, setBootstrapNeeded),
 		vibcModule,
 		vbankModule,
 		lienModule,
@@ -809,57 +825,91 @@ func normalizeModuleAccount(ctx sdk.Context, ak authkeeper.AccountKeeper, name s
 type cosmosInitAction struct {
 	Type        string             `json:"type"`
 	ChainID     string             `json:"chainID"`
+	IsBootstrap bool               `json:"isBootstrap"`
 	Params      swingset.Params    `json:"params"`
-	StoragePort int                `json:"storagePort"`
 	SupplyCoins sdk.Coins          `json:"supplyCoins"`
-	VibcPort    int                `json:"vibcPort"`
-	VbankPort   int                `json:"vbankPort"`
-	LienPort    int                `json:"lienPort"`
 	UpgradePlan *upgradetypes.Plan `json:"upgradePlan,omitempty"`
+	LienPort    int                `json:"lienPort"`
+	StoragePort int                `json:"storagePort"`
+	VbankPort   int                `json:"vbankPort"`
+	VibcPort    int                `json:"vibcPort"`
 }
 
 // Name returns the name of the App
 func (app *GaiaApp) Name() string { return app.BaseApp.Name() }
 
-func (app *GaiaApp) MustInitController(ctx sdk.Context) {
-	if app.controllerInited {
-		return
+// CheckControllerInited exits if the controller initialization state does not match `expected`.
+func (app *GaiaApp) CheckControllerInited(expected bool) {
+	if app.controllerInited != expected {
+		fmt.Fprintf(os.Stderr, "controllerInited != %t\n", expected)
+		debug.PrintStack()
+		os.Exit(1)
 	}
+}
+
+// initController sends the initialization message to the VM.
+// Exits if the controller has already been initialized.
+func (app *GaiaApp) initController(ctx sdk.Context, bootstrap bool) {
+	app.CheckControllerInited(false)
 	app.controllerInited = true
 	// Begin initializing the controller here.
 	action := &cosmosInitAction{
 		Type:        "AG_COSMOS_INIT",
 		ChainID:     ctx.ChainID(),
+		IsBootstrap: bootstrap,
 		Params:      app.SwingSetKeeper.GetParams(ctx),
-		StoragePort: app.vstoragePort,
 		SupplyCoins: sdk.NewCoins(app.BankKeeper.GetSupply(ctx, "uist")),
-		VibcPort:    app.vibcPort,
-		VbankPort:   app.vbankPort,
-		LienPort:    app.lienPort,
 		UpgradePlan: app.upgradePlan,
+		LienPort:    app.lienPort,
+		StoragePort: app.vstoragePort,
+		VbankPort:   app.vbankPort,
+		VibcPort:    app.vibcPort,
 	}
+	// This really abuses `BlockingSend` to get back at `sendToController`
 	out, err := app.SwingSetKeeper.BlockingSend(ctx, action)
 
 	// fmt.Fprintf(os.Stderr, "AG_COSMOS_INIT Returned from SwingSet: %s, %v\n", out, err)
 
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "Cannot initialize Controller", err)
-		os.Exit(1)
+		panic(errors.Wrap(err, "cannot initialize Controller"))
 	}
 	var res bool
 	err = json.Unmarshal([]byte(out), &res)
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "Cannot unmarshal Controller init response", out, err)
-		os.Exit(1)
+		panic(errors.Wrapf(err, "cannot unmarshal Controller init response: %s", out))
 	}
 	if !res {
-		fmt.Fprintln(os.Stderr, "Controller negative init response")
-		os.Exit(1)
+		panic(fmt.Errorf("controller negative init response"))
+	}
+}
+
+type bootstrapBlockAction struct {
+	Type      string `json:"type"`
+	BlockTime int64  `json:"blockTime"`
+}
+
+// BootstrapController initializes the controller (with the bootstrap flag) and sends a bootstrap action.
+func (app *GaiaApp) BootstrapController(ctx sdk.Context) error {
+	app.initController(ctx, true)
+
+	stdlog.Println("Running SwingSet until bootstrap is ready")
+	// Just run the SwingSet kernel to finish bootstrap and get ready to open for
+	// business.
+	action := &bootstrapBlockAction{
+		Type:      "BOOTSTRAP_BLOCK",
+		BlockTime: ctx.BlockTime().Unix(),
 	}
+
+	_, err := app.SwingSetKeeper.BlockingSend(ctx, action)
+	return err
 }
 
 // BeginBlocker application updates every begin block
 func (app *GaiaApp) BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock) abci.ResponseBeginBlock {
+	if !app.controllerInited {
+		app.initController(ctx, false)
+	}
+
 	return app.mm.BeginBlock(ctx, req)
 }
 
@@ -878,6 +928,21 @@ func (app *GaiaApp) InitChainer(ctx sdk.Context, req abci.RequestInitChain) abci
 	app.UpgradeKeeper.SetModuleVersionMap(ctx, app.mm.GetVersionMap())
 	res := app.mm.InitGenesis(ctx, app.appCodec, genesisState)
 
+	// initialize the provision and reserve module accounts, to avoid their implicit creation
+	// as a default account upon receiving a transfer. See BlockedAddrs().
+	normalizeModuleAccount(ctx, app.AccountKeeper, vbanktypes.ProvisionPoolName)
+	normalizeModuleAccount(ctx, app.AccountKeeper, vbanktypes.ReservePoolName)
+
+	if app.bootstrapNeeded {
+		err := app.BootstrapController(ctx)
+		// fmt.Fprintf(os.Stderr, "BOOTSTRAP_BLOCK Returned from swingset: %s, %v\n", out, err)
+		if err != nil {
+			// NOTE: A failed BOOTSTRAP_BLOCK means that the SwingSet state is inconsistent.
+			// Panic here, in the hopes that a replay from scratch will fix the problem.
+			panic(err)
+		}
+	}
+
 	// Agoric: report the genesis time explicitly.
 	genTime := req.GetTime()
 	if genTime.After(time.Now()) {
@@ -885,11 +950,6 @@ func (app *GaiaApp) InitChainer(ctx sdk.Context, req abci.RequestInitChain) abci
 		stdlog.Printf("Genesis time %s is in %s\n", genTime, d)
 	}
 
-	// initialize the provision and reserve module accounts, to avoid their implicit creation
-	// as a default account upon receiving a transfer. See BockedAddrs().
-	normalizeModuleAccount(ctx, app.AccountKeeper, vbanktypes.ProvisionPoolName)
-	normalizeModuleAccount(ctx, app.AccountKeeper, vbanktypes.ReservePoolName)
-
 	return res
 }
 

package/git-revision.txt

@@ -1 +1 @@
-afe8a6e
+857e650

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/cosmos",
-  "version": "0.34.2-dev-afe8a6e.0+afe8a6e",
+  "version": "0.34.2-dev-857e650.0+857e650",
   "description": "Connect JS to the Cosmos blockchain SDK",
   "parsers": {
     "js": "mjs"
@@ -35,5 +35,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "afe8a6e7881372935ed998ec096ae0c31cfe5f21"
+  "gitHead": "857e6508f673ffb20e5efc409a3397616e31093d"
 }

package/vm/controller.go

@@ -8,7 +8,6 @@ import (
 
 type ControllerContext struct {
 	Context               sdk.Context
-	StoragePort           int
 	IBCChannelHandlerPort int
 }
 
@@ -74,7 +73,7 @@ func UnregisterPortHandler(portNum int) error {
 func ReceiveFromController(portNum int, msg string) (string, error) {
 	handler := portToHandler[portNum]
 	if handler == nil {
-		return "", fmt.Errorf("Unregistered port %d", portNum)
+		return "", fmt.Errorf("unregistered port %d", portNum)
 	}
 	return handler.Receive(&controllerContext, msg)
 }

package/x/swingset/abci.go

@@ -9,13 +9,11 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	abci "github.com/tendermint/tendermint/abci/types"
 
-	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/types"
 )
 
 type beginBlockAction struct {
 	Type        string       `json:"type"`
-	StoragePort int          `json:"storagePort"`
 	BlockHeight int64        `json:"blockHeight"`
 	BlockTime   int64        `json:"blockTime"`
 	ChainID     string       `json:"chainID"`
@@ -39,7 +37,6 @@ func BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock, keeper Keeper) erro
 
 	action := &beginBlockAction{
 		Type:        "BEGIN_BLOCK",
-		StoragePort: vm.GetPort("vstorage"),
 		BlockHeight: ctx.BlockHeight(),
 		BlockTime:   ctx.BlockTime().Unix(),
 		ChainID:     ctx.ChainID(),

package/x/swingset/genesis.go

@@ -3,12 +3,9 @@ package swingset
 import (
 	// "os"
 	"fmt"
-	stdlog "log"
 
-	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	abci "github.com/tendermint/tendermint/abci/types"
 )
 
 func NewGenesisState() *types.GenesisState {
@@ -31,40 +28,14 @@ func DefaultGenesisState() *types.GenesisState {
 	}
 }
 
-type bootstrapBlockAction struct {
-	Type        string `json:"type"`
-	BlockTime   int64  `json:"blockTime"`
-	StoragePort int    `json:"storagePort"`
-}
-
-func BootSwingset(ctx sdk.Context, keeper Keeper) error {
-  // Just run the SwingSet kernel to finish bootstrap and get ready to open for
-	// business.
-	action := &bootstrapBlockAction{
-		Type:        "BOOTSTRAP_BLOCK",
-		BlockTime:   ctx.BlockTime().Unix(),
-		StoragePort: vm.GetPort("vstorage"),
-	}
-
-	_, err := keeper.BlockingSend(ctx, action)
-	return err
-}
-
-func InitGenesis(ctx sdk.Context, keeper Keeper, data *types.GenesisState) []abci.ValidatorUpdate {
+// InitGenesis initializes the (Cosmos-side) SwingSet state from the GenesisState.
+// Returns whether the app should send a bootstrap action to the controller.
+func InitGenesis(ctx sdk.Context, keeper Keeper, data *types.GenesisState) bool {
 	keeper.SetParams(ctx, data.GetParams())
 	keeper.SetState(ctx, data.GetState())
 
-	stdlog.Println("Running SwingSet until bootstrap is ready")
-	err := BootSwingset(ctx, keeper)
-	
-	// fmt.Fprintf(os.Stderr, "BOOTSTRAP_BLOCK Returned from swingset: %s, %v\n", out, err)
-	if err != nil {
-		// NOTE: A failed BOOTSTRAP_BLOCK means that the SwingSet state is inconsistent.
-		// Panic here, in the hopes that a replay from scratch will fix the problem.
-		panic(err)
-	}
-
-	return []abci.ValidatorUpdate{}
+	// TODO: bootstrap only if not restoring swing-store from genesis state
+	return true
 }
 
 func ExportGenesis(ctx sdk.Context, k Keeper) *types.GenesisState {

package/x/swingset/keeper/msg_server.go

@@ -25,7 +25,6 @@ type deliverInboundAction struct {
 	Peer        string          `json:"peer"`
 	Messages    [][]interface{} `json:"messages"`
 	Ack         uint64          `json:"ack"`
-	StoragePort int             `json:"storagePort"`
 	BlockHeight int64           `json:"blockHeight"`
 	BlockTime   int64           `json:"blockTime"`
 }
@@ -58,7 +57,6 @@ func (keeper msgServer) DeliverInbound(goCtx context.Context, msg *types.MsgDeli
 		Peer:        msg.Submitter.String(),
 		Messages:    messages,
 		Ack:         msg.Ack,
-		StoragePort: vm.GetPort("vstorage"),
 		BlockHeight: ctx.BlockHeight(),
 		BlockTime:   ctx.BlockTime().Unix(),
 	}

package/x/swingset/keeper/snapshotter.go

@@ -41,6 +41,8 @@ func sanitizeArtifactName(name string) string {
 }
 
 type activeSnapshot struct {
+	// Whether the operation in progress is a restore
+	isRestore bool
 	// The block height of the snapshot in progress
 	height int64
 	// The logger for this snapshot
@@ -62,17 +64,13 @@ type exportManifest struct {
 	Artifacts [][2]string `json:"artifacts"`
 }
 
-type SwingStoreExporter interface {
-	ExportSwingStore(ctx sdk.Context) []*vstoragetypes.DataEntry
-}
-
 type SwingsetSnapshotter struct {
-	isConfigured      func() bool
-	takeSnapshot      func(height int64)
-	newRestoreContext func(height int64) sdk.Context
-	logger            log.Logger
-	exporter          SwingStoreExporter
-	blockingSend      func(action vm.Jsonable) (string, error)
+	isConfigured            func() bool
+	takeSnapshot            func(height int64)
+	newRestoreContext       func(height int64) sdk.Context
+	logger                  log.Logger
+	getSwingStoreExportData func(ctx sdk.Context) []*vstoragetypes.DataEntry
+	blockingSend            func(action vm.Jsonable, mustNotBeInited bool) (string, error)
 	// Only modified by the main goroutine.
 	activeSnapshot *activeSnapshot
 }
@@ -84,49 +82,64 @@ type snapshotAction struct {
 	Args        []json.RawMessage `json:"args,omitempty"`
 }
 
-func NewSwingsetSnapshotter(app *baseapp.BaseApp, exporter SwingStoreExporter, sendToController func(bool, string) (string, error)) SwingsetSnapshotter {
-	// The sendToController performed by this submodule are non-deterministic.
-	// This submodule will send messages to JS from goroutines at unpredictable
-	// times, but this is safe because when handling the messages, the JS side
-	// does not perform operations affecting consensus and ignores state changes
-	// since committing the previous block.
-	// Since this submodule implements block level commit synchronization, the
-	// processing and results are both insensitive to sub-block timing of messages.
-
-	blockingSend := func(action vm.Jsonable) (string, error) {
-		bz, err := json.Marshal(action)
-		if err != nil {
-			return "", err
-		}
-		return sendToController(true, string(bz))
-	}
-
+// NewSwingsetSnapshotter creates a SwingsetSnapshotter which exclusively
+// manages communication with the JS side for Swingset snapshots, ensuring
+// insensitivity to sub-block timing, and enforcing concurrency requirements.
+// The caller of this submodule must arrange block level commit synchronization,
+// to ensure the results are deterministic.
+//
+// Some `blockingSend` calls performed by this submodule are non-deterministic.
+// This submodule will send messages to JS from goroutines at unpredictable
+// times, but this is safe because when handling the messages, the JS side
+// does not perform operations affecting consensus and ignores state changes
+// since committing the previous block.
+// Some other `blockingSend` calls however do change the JS swing-store and
+// must happen before the Swingset controller on the JS side was inited.
+func NewSwingsetSnapshotter(
+	app *baseapp.BaseApp,
+	getSwingStoreExportData func(ctx sdk.Context) []*vstoragetypes.DataEntry,
+	blockingSend func(action vm.Jsonable, mustNotBeInited bool) (string, error),
+) SwingsetSnapshotter {
 	return SwingsetSnapshotter{
 		isConfigured: func() bool { return app.SnapshotManager() != nil },
 		takeSnapshot: app.Snapshot,
 		newRestoreContext: func(height int64) sdk.Context {
 			return app.NewUncachedContext(false, tmproto.Header{Height: height})
 		},
-		logger:         app.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName), "submodule", "snapshotter"),
-		exporter:       exporter,
-		blockingSend:   blockingSend,
-		activeSnapshot: nil,
+		logger:                  app.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName), "submodule", "snapshotter"),
+		getSwingStoreExportData: getSwingStoreExportData,
+		blockingSend:            blockingSend,
+		activeSnapshot:          nil,
 	}
 }
 
+// checkNotActive returns an error if there is an active snapshot.
+func (snapshotter *SwingsetSnapshotter) checkNotActive() error {
+	active := snapshotter.activeSnapshot
+	if active != nil {
+		select {
+		case <-active.done:
+			snapshotter.activeSnapshot = nil
+		default:
+			if active.isRestore {
+				return fmt.Errorf("snapshot restore already in progress for height %d", active.height)
+			} else {
+				return fmt.Errorf("snapshot already in progress for height %d", active.height)
+			}
+		}
+	}
+	return nil
+}
+
 // InitiateSnapshot synchronously initiates a snapshot for the given height.
 // If a snapshot is already in progress, or if no snapshot manager is configured,
 // this will fail.
 // The snapshot operation is performed in a goroutine, and synchronized with the
 // main thread through the `WaitUntilSnapshotStarted` method.
 func (snapshotter *SwingsetSnapshotter) InitiateSnapshot(height int64) error {
-	if snapshotter.activeSnapshot != nil {
-		select {
-		case <-snapshotter.activeSnapshot.done:
-			snapshotter.activeSnapshot = nil
-		default:
-			return fmt.Errorf("snapshot already in progress for height %d", snapshotter.activeSnapshot.height)
-		}
+	err := snapshotter.checkNotActive()
+	if err != nil {
+		return err
 	}
 
 	if !snapshotter.isConfigured() {
@@ -157,7 +170,7 @@ func (snapshotter *SwingsetSnapshotter) InitiateSnapshot(height int64) error {
 		}
 
 		// blockingSend for COSMOS_SNAPSHOT action is safe to call from a goroutine
-		_, err := snapshotter.blockingSend(action)
+		_, err := snapshotter.blockingSend(action, false)
 
 		if err != nil {
 			// First indicate a snapshot is no longer in progress if the call to
@@ -188,7 +201,7 @@ func (snapshotter *SwingsetSnapshotter) InitiateSnapshot(height int64) error {
 			BlockHeight: height,
 			Request:     "discard",
 		}
-		_, err = snapshotter.blockingSend(action)
+		_, err = snapshotter.blockingSend(action, false)
 
 		if err != nil {
 			logger.Error("failed to discard swingset snapshot", "err", err)
@@ -286,7 +299,7 @@ func (snapshotter *SwingsetSnapshotter) SnapshotExtension(height uint64, payload
 		BlockHeight: activeSnapshot.height,
 		Request:     "retrieve",
 	}
-	out, err := snapshotter.blockingSend(action)
+	out, err := snapshotter.blockingSend(action, false)
 
 	if err != nil {
 		return err
@@ -369,6 +382,30 @@ func (snapshotter *SwingsetSnapshotter) RestoreExtension(height uint64, format u
 		return snapshots.ErrUnknownFormat
 	}
 
+	err := snapshotter.checkNotActive()
+	if err != nil {
+		return err
+	}
+
+	// We technically don't need to create an active snapshot here since both
+	// `InitiateSnapshot` and `RestoreExtension` should only be called from the
+	// main thread, but it doesn't cost much to add in case things go wrong.
+	active := &activeSnapshot{
+		isRestore: true,
+		height:    int64(height),
+		logger:    snapshotter.logger,
+		// goroutine synchronization is unnecessary since anything checking should
+		// be called from the same thread.
+		// Effectively `WaitUntilSnapshotStarted` would block infinitely and
+		// and `InitiateSnapshot` will error when calling `checkNotActive`.
+		startedResult: nil,
+		done:          nil,
+	}
+	snapshotter.activeSnapshot = active
+	defer func() {
+		snapshotter.activeSnapshot = nil
+	}()
+
 	ctx := snapshotter.newRestoreContext(int64(height))
 
 	exportDir, err := os.MkdirTemp("", fmt.Sprintf("agd-state-sync-restore-%d-*", height))
@@ -392,7 +429,7 @@ func (snapshotter *SwingsetSnapshotter) RestoreExtension(height uint64, format u
 	// At this point the content of the cosmos DB has been verified against the
 	// AppHash, which means the SwingStore data it contains can be used as the
 	// trusted root against which to validate the artifacts.
-	swingStoreEntries := snapshotter.exporter.ExportSwingStore(ctx)
+	swingStoreEntries := snapshotter.getSwingStoreExportData(ctx)
 
 	if len(swingStoreEntries) > 0 {
 		encoder := json.NewEncoder(exportDataFile)
@@ -480,7 +517,7 @@ func (snapshotter *SwingsetSnapshotter) RestoreExtension(height uint64, format u
 		Args:        []json.RawMessage{encodedExportDir},
 	}
 
-	_, err = snapshotter.blockingSend(action)
+	_, err = snapshotter.blockingSend(action, true)
 	if err != nil {
 		return err
 	}

package/x/swingset/keeper/snapshotter_test.go

@@ -2,6 +2,7 @@ package keeper
 
 import (
 	"errors"
+	"io"
 	"testing"
 
 	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
@@ -16,7 +17,7 @@ func newTestSnapshotter() SwingsetSnapshotter {
 		takeSnapshot:      func(height int64) {},
 		newRestoreContext: func(height int64) sdk.Context { return sdk.Context{} },
 		logger:            logger,
-		blockingSend:      func(action vm.Jsonable) (string, error) { return "", nil },
+		blockingSend:      func(action vm.Jsonable, mustNotBeInited bool) (string, error) { return "", nil },
 	}
 }
 
@@ -40,6 +41,15 @@ func TestSnapshotInProgress(t *testing.T) {
 		t.Error("wanted error for snapshot in progress")
 	}
 
+	err = swingsetSnapshotter.RestoreExtension(
+		456, SnapshotFormat,
+		func() ([]byte, error) {
+			return nil, io.EOF
+		})
+	if err == nil {
+		t.Error("wanted error for snapshot in progress")
+	}
+
 	close(ch)
 	<-swingsetSnapshotter.activeSnapshot.done
 	err = swingsetSnapshotter.InitiateSnapshot(456)
@@ -89,7 +99,7 @@ func TestSecondCommit(t *testing.T) {
 
 func TestInitiateFails(t *testing.T) {
 	swingsetSnapshotter := newTestSnapshotter()
-	swingsetSnapshotter.blockingSend = func(action vm.Jsonable) (string, error) {
+	swingsetSnapshotter.blockingSend = func(action vm.Jsonable, mustNotBeInited bool) (string, error) {
 		if action.(*snapshotAction).Request == "initiate" {
 			return "", errors.New("initiate failed")
 		}
@@ -116,7 +126,7 @@ func TestInitiateFails(t *testing.T) {
 
 func TestRetrievalFails(t *testing.T) {
 	swingsetSnapshotter := newTestSnapshotter()
-	swingsetSnapshotter.blockingSend = func(action vm.Jsonable) (string, error) {
+	swingsetSnapshotter.blockingSend = func(action vm.Jsonable, mustNotBeInited bool) (string, error) {
 		if action.(*snapshotAction).Request == "retrieve" {
 			return "", errors.New("retrieve failed")
 		}
@@ -152,7 +162,7 @@ func TestRetrievalFails(t *testing.T) {
 func TestDiscard(t *testing.T) {
 	discardCalled := false
 	swingsetSnapshotter := newTestSnapshotter()
-	swingsetSnapshotter.blockingSend = func(action vm.Jsonable) (string, error) {
+	swingsetSnapshotter.blockingSend = func(action vm.Jsonable, mustNotBeInited bool) (string, error) {
 		if action.(*snapshotAction).Request == "discard" {
 			discardCalled = true
 		}

package/x/swingset/module.go

@@ -80,14 +80,16 @@ func (AppModuleBasic) GetTxCmd() *cobra.Command {
 
 type AppModule struct {
 	AppModuleBasic
-	keeper Keeper
+	keeper             Keeper
+	setBootstrapNeeded func()
 }
 
 // NewAppModule creates a new AppModule Object
-func NewAppModule(k Keeper) AppModule {
+func NewAppModule(k Keeper, setBootstrapNeeded func()) AppModule {
 	am := AppModule{
-		AppModuleBasic: AppModuleBasic{},
-		keeper:         k,
+		AppModuleBasic:     AppModuleBasic{},
+		keeper:             k,
+		setBootstrapNeeded: setBootstrapNeeded,
 	}
 	return am
 }
@@ -147,7 +149,11 @@ func (am AppModule) EndBlock(ctx sdk.Context, req abci.RequestEndBlock) []abci.V
 func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, data json.RawMessage) []abci.ValidatorUpdate {
 	var genesisState types.GenesisState
 	cdc.MustUnmarshalJSON(data, &genesisState)
-	return InitGenesis(ctx, am.keeper, &genesisState)
+	bootstrapNeeded := InitGenesis(ctx, am.keeper, &genesisState)
+	if bootstrapNeeded {
+		am.setBootstrapNeeded()
+	}
+	return []abci.ValidatorUpdate{}
 }
 
 func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.RawMessage {

package/x/vstorage/genesis.go

@@ -22,9 +22,6 @@ func ValidateGenesis(data *types.GenesisState) error {
 		if err := types.ValidatePath(entry.Path); err != nil {
 			return fmt.Errorf("genesis vstorage.data entry %q has invalid path format: %s", entry.Path, err)
 		}
-		if entry.Value == "" {
-			return fmt.Errorf("genesis vstorage.data entry %q has no data", entry.Path)
-		}
 	}
 	return nil
 }

package/x/vstorage/keeper/keeper.go

@@ -181,30 +181,6 @@ func (k Keeper) ImportStorage(ctx sdk.Context, entries []*types.DataEntry) {
 	}
 }
 
-func (k Keeper) MigrateNoDataPlaceholders(ctx sdk.Context) {
-	store := ctx.KVStore(k.storeKey)
-
-	iterator := sdk.KVStorePrefixIterator(store, nil)
-
-	// Copy empty keys first since cosmos stores do not support writing keys
-	// while an iterator is open over the domain
-	emptyKeys := [][]byte{}
-	for ; iterator.Valid(); iterator.Next() {
-		rawValue := iterator.Value()
-		if bytes.Equal(rawValue, types.EncodedDataPrefix) {
-			key := iterator.Key()
-			clonedKey := make([]byte, len(key))
-			copy(clonedKey, key)
-			emptyKeys = append(emptyKeys, clonedKey)
-		}
-	}
-	iterator.Close()
-
-	for _, key := range emptyKeys {
-		store.Set(key, types.EncodedNoDataValue)
-	}
-}
-
 func (k Keeper) EmitChange(ctx sdk.Context, change *ProposedChange) {
 	if change.NewValue == change.ValueFromLastBlock {
 		// No change.

package/x/vstorage/keeper/keeper_test.go

@@ -273,44 +273,3 @@ func TestStorageNotify(t *testing.T) {
 		t.Errorf("got after second flush events %#v, want %#v", got, expectedAfterFlushEvents)
 	}
 }
-
-func TestStorageMigrate(t *testing.T) {
-	testKit := makeTestKit()
-	ctx, keeper := testKit.ctx, testKit.vstorageKeeper
-
-	// Simulate a pre-migration storage with empty string as placeholders
-	keeper.SetStorage(ctx, types.NewStorageEntry("key1", "value1"))
-	keeper.SetStorage(ctx, types.NewStorageEntry("key1.child1.grandchild1", "value1grandchild"))
-	keeper.SetStorage(ctx, types.NewStorageEntry("key1.child1", ""))
-
-	// Do a deep set.
-	keeper.SetStorage(ctx, types.NewStorageEntry("key2.child2.grandchild2", "value2grandchild"))
-	keeper.SetStorage(ctx, types.NewStorageEntry("key2.child2.grandchild2a", "value2grandchilda"))
-	keeper.SetStorage(ctx, types.NewStorageEntry("key2.child2", ""))
-	keeper.SetStorage(ctx, types.NewStorageEntry("key2", ""))
-
-	keeper.MigrateNoDataPlaceholders(ctx)
-
-	if keeper.HasStorage(ctx, "key1.child1") {
-		t.Errorf("has key1.child1, want no value")
-	}
-	if keeper.HasStorage(ctx, "key2.child2") {
-		t.Errorf("has key2.child2, want no value")
-	}
-	if keeper.HasStorage(ctx, "key2") {
-		t.Errorf("has key2, want no value")
-	}
-
-	// Check the export.
-	expectedExport := []*types.DataEntry{
-		{Path: "key1", Value: "value1"},
-		{Path: "key1.child1.grandchild1", Value: "value1grandchild"},
-		{Path: "key2.child2.grandchild2", Value: "value2grandchild"},
-		{Path: "key2.child2.grandchild2a", Value: "value2grandchilda"},
-	}
-	got := keeper.ExportStorage(ctx)
-	if !reflect.DeepEqual(got, expectedExport) {
-		t.Errorf("got export %q, want %q", got, expectedExport)
-	}
-	keeper.ImportStorage(ctx, got)
-}