@agoric/cosmos 0.34.2-dev-5dc325b.0 → 0.35.0-getting-started-dev-26244e8.0

package/CHANGELOG.md

@@ -3,6 +3,79 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [0.35.0-u12.0](https://github.com/Agoric/agoric-sdk/compare/@agoric/cosmos@0.35.0-u11wf.0...@agoric/cosmos@0.35.0-u12.0) (2023-11-10)
+
+
+### ⚠ BREAKING CHANGES
+
+* **vstorage:** Enforce path validation
+
+### Features
+
+* **cosmos:** Lower `BlockParams.MaxBytes` to 5MB ([84908e5](https://github.com/Agoric/agoric-sdk/commit/84908e5a5a181e3f64da0e298d0105fedb97570a))
+
+### Bug Fixes
+
+* **vibc:** accommodate ibc-go v3 breaking changes ([f582901](https://github.com/Agoric/agoric-sdk/commit/f582901fb3835d95d493c777aac6a63fc3ee4681))
+* **vibc:** put extraneous `CounterpartyChannelID` in `Counterparty` struct ([9469971](https://github.com/Agoric/agoric-sdk/commit/946997192cec0ed6b07fdaa18d8f380f460ab004))
+* **vstorage:** Enforce path validation ([d8db331](https://github.com/Agoric/agoric-sdk/commit/d8db3310fb21a8546388694752889f3563733010)), closes [#8337](https://github.com/Agoric/agoric-sdk/issues/8337)
+* **cosmos:** Update cosmos-sdk with fix for state-sync restore of large payloads ([e04b398](https://github.com/Agoric/agoric-sdk/commit/e04b398bf16d884fa4708c16d4c03b39cc4e0f1b)), closes [#8325](https://github.com/Agoric/agoric-sdk/issues/8325)
+
+
+
+## [0.35.0-u11wf.0](https://github.com/Agoric/agoric-sdk/compare/@agoric/cosmos@0.35.0-u11.0...@agoric/cosmos@0.35.0-u11wf.0) (2023-09-23)
+
+**Note:** Version bump only for package @agoric/cosmos
+
+
+
+
+
+## [0.35.0-u11.0](https://github.com/Agoric/agoric-sdk/compare/@agoric/cosmos@0.34.1...@agoric/cosmos@0.35.0-u11.0) (2023-08-24)
+
+
+### ⚠ BREAKING CHANGES
+
+* **cosmos:** add required export-dir export cmd option
+* remove deprecated `ag-cosmos-helper`
+
+### Features
+
+* **agd:** try harder to find cosmic-swingset ([a1d1666](https://github.com/Agoric/agoric-sdk/commit/a1d1666997c2f5b9c7bf14748f6d9603c0b3c5f9))
+* **cosmic-swingset:** add repair-metadata snapshot restore option ([ebbb982](https://github.com/Agoric/agoric-sdk/commit/ebbb9829f1f845c0932ae92b23d0d43be9a0e196))
+* **cosmic-swingset:** replace import/export options ([393b91b](https://github.com/Agoric/agoric-sdk/commit/393b91baaa25c61364955102e8cfcdcaec90870d))
+* **cosmic-swingset:** use x/swingset for swing-store export data ([3336b62](https://github.com/Agoric/agoric-sdk/commit/3336b62fbb10bd2293a832f8c30e590530d14213))
+* **cosmos:** add required export-dir export cmd option ([8d2571c](https://github.com/Agoric/agoric-sdk/commit/8d2571c51c2fe08d630dd2897d7e5e1b45ab45c9))
+* **cosmos:** fix and migrate swing-store ([6ba1957](https://github.com/Agoric/agoric-sdk/commit/6ba19571688518dcfdc4553a0c822695a61908b1))
+* **cosmos:** KVEntry implements json Marshaler and Unmarshaller ([6d2fe11](https://github.com/Agoric/agoric-sdk/commit/6d2fe11d144c5bbdc1611b59c84b6842e8084cb9))
+* **cosmos:** spawn JS on export command ([fe4eb56](https://github.com/Agoric/agoric-sdk/commit/fe4eb56facf83569aa343f098e97c6229556afa9))
+* **cosmos:** wire new swingset port handler ([3361b25](https://github.com/Agoric/agoric-sdk/commit/3361b25ddaa00116476d3de1107e800499ab5c21))
+* **x/swingset:** add store data to genesis ([df72903](https://github.com/Agoric/agoric-sdk/commit/df729030643a097262ad1393503d380e243107eb))
+* **x/swingset:** add WaitUntilSwingStoreExportDone ([f8acd22](https://github.com/Agoric/agoric-sdk/commit/f8acd22381ff3da4682bcb0cdcf71665095506a4))
+* **x/swingset:** allow taking snapshot latest height ([0c0e742](https://github.com/Agoric/agoric-sdk/commit/0c0e74227d34d49ac7ce76ce8e92715816d5ea6a))
+* **x/swingset:** export swing store in genesis ([e5f9425](https://github.com/Agoric/agoric-sdk/commit/e5f9425e74c7235323cd6b1b88540b73b57a69a6))
+* **x/swingset:** import swing store from genesis state ([2446cf4](https://github.com/Agoric/agoric-sdk/commit/2446cf43bb13aad7de0805cd7e33c966d2e31016))
+* Cosmos upgrade handler calls swingset ([66f7bcc](https://github.com/Agoric/agoric-sdk/commit/66f7bccce7ce30cf5b9e1e5321710567c05723cb))
+
+
+### Bug Fixes
+
+* **cosmos:** don't init controller before upgrade ([e567c21](https://github.com/Agoric/agoric-sdk/commit/e567c21a224d239c467f740bb937f84b18db9dd7))
+* **cosmos:** module order independent init and bootstrap ([3ce4012](https://github.com/Agoric/agoric-sdk/commit/3ce4012ea99b39b2d6bfd422b1d7ea7a7e904568))
+* **cosmos:** prevent Golang error wrapping stack frame divergence ([1d8acf6](https://github.com/Agoric/agoric-sdk/commit/1d8acf6270cadfbcdafb1081360155260d031ac1))
+* **cosmos:** Support building on Linux aarch64 ([475708e](https://github.com/Agoric/agoric-sdk/commit/475708e63bb95d75184072547ca92586a978c5a0))
+* **x/swingset:** enforce snapshot restore before init ([c946d58](https://github.com/Agoric/agoric-sdk/commit/c946d5866ef956c198d7ea14936eb9904aa272ae))
+* **x/swingset:** guard snapshot restore for concurrency ([5320a30](https://github.com/Agoric/agoric-sdk/commit/5320a30a873455764104e13d89131e30a93a238c))
+* **x/swingset:** switch export/import to replay artifact level ([c037ea3](https://github.com/Agoric/agoric-sdk/commit/c037ea3931877fe4d56df5b82cc7c3eb77a84a53))
+* **x/vstorage:** value can be empty in genesis data ([9a51df5](https://github.com/Agoric/agoric-sdk/commit/9a51df515b87638b869564ab08445a0ce0d55707))
+
+
+### Build System
+
+* remove deprecated `ag-cosmos-helper` ([ee43112](https://github.com/Agoric/agoric-sdk/commit/ee431121e3f93406896f8a9e7d949fbf1427c44e))
+
+
+
 ### [0.34.1](https://github.com/Agoric/agoric-sdk/compare/@agoric/cosmos@0.34.0...@agoric/cosmos@0.34.1) (2023-06-09)
 
 **Note:** Version bump only for package @agoric/cosmos

package/app/app.go

@@ -1,7 +1,6 @@
 package gaia
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -289,7 +288,7 @@ func NewGaiaApp(
 	appOpts servertypes.AppOptions,
 	baseAppOptions ...func(*baseapp.BaseApp),
 ) *GaiaApp {
-	defaultController := func(ctx context.Context, needReply bool, str string) (string, error) {
+	defaultController := func(needReply bool, str string) (string, error) {
 		fmt.Fprintln(os.Stderr, "FIXME: Would upcall to controller with", str)
 		return "", nil
 	}
@@ -301,7 +300,7 @@ func NewGaiaApp(
 }
 
 func NewAgoricApp(
-	sendToController func(context.Context, bool, string) (string, error),
+	sendToController func(bool, string) (string, error),
 	logger log.Logger, db dbm.DB, traceStore io.Writer, loadLatest bool, skipUpgradeHeights map[int64]bool,
 	homePath string, invCheckPeriod uint, encodingConfig gaiaappparams.EncodingConfig, appOpts servertypes.AppOptions, baseAppOptions ...func(*baseapp.BaseApp),
 ) *GaiaApp {
@@ -451,7 +450,7 @@ func NewAgoricApp(
 		app.CheckControllerInited(true)
 		// We use SwingSet-level metering to charge the user for the call.
 		defer vm.SetControllerContext(ctx)()
-		return sendToController(sdk.WrapSDKContext(ctx), true, str)
+		return sendToController(true, str)
 	}
 
 	setBootstrapNeeded := func() {
@@ -483,7 +482,7 @@ func NewAgoricApp(
 			if err != nil {
 				return "", err
 			}
-			return sendToController(context.Background(), true, string(bz))
+			return sendToController(true, string(bz))
 		},
 	)
 

package/cmd/agd/main.go

@@ -1,158 +1,36 @@
 package main
 
 import (
-	"context"
-	"errors"
-	"net/rpc"
-	"net/rpc/jsonrpc"
 	"os"
-	"os/exec"
 	"syscall"
-	"time"
 
-	"github.com/spf13/cast"
 	"github.com/tendermint/tendermint/libs/log"
 
 	gaia "github.com/Agoric/agoric-sdk/golang/cosmos/app"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/daemon"
 	daemoncmd "github.com/Agoric/agoric-sdk/golang/cosmos/daemon/cmd"
-	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
-	"github.com/Agoric/agoric-sdk/golang/cosmos/vm/jsonrpcconn"
-	servertypes "github.com/cosmos/cosmos-sdk/server/types"
 )
 
-// TerminateSubprocessGracePeriod is how long we wait between closing the pipe
-// waiting for it to exit, then sending a termination signal.
-const TerminateSubprocessGracePeriod = 3 * time.Second
-
-// KillSubprocessGracePeriod is how long we wait between sending a subprocess a
-// termination signal, waiting for it to exit, then killing it.
-const KillSubprocessGracePeriod = 5 * time.Second
-
-// makeShutdown returns a function that terminates the vm.
-func makeShutdown(cmd *exec.Cmd, writer *os.File) func() error {
-	return func() error {
-		// Stop talking to the subprocess.
-		_ = writer.Close()
-		go func() {
-			// Wait a bit.
-			time.Sleep(TerminateSubprocessGracePeriod)
-			// Then punch it in the shoulder.
-			_ = cmd.Process.Signal(os.Interrupt)
-			// Wait a bit.
-			time.Sleep(KillSubprocessGracePeriod)
-			// Then blow it away.
-			_ = cmd.Process.Kill()
-		}()
-		// Wait for it to keel over.
-		return cmd.Wait()
-	}
-}
-
-
-// main is the entry point of the agd daemon.  It determines whether to
-// initialize JSON-RPC communications with the separate `--split-vm` VM process,
-// or just to give up control entirely to another binary.
 func main() {
-	var vmClient *rpc.Client
-	var shutdown func() error
-
-	nodePort := 1
-	sendToNode := func(ctx context.Context, needReply bool, str string) (string, error) {
-		if vmClient == nil {
-			return "", errors.New("sendToVM called without VM client set up")
-		}
-
-		if str == "shutdown" {
-			// We could ask nicely, but don't bother.
-			if shutdown != nil {
-				return "", shutdown()
-			}
-			return "", nil
-		}
-
-		msg := vm.Message{
-			Port: nodePort,
-			NeedsReply: needReply,
-			Data: str,
-		}
-		var reply string
-		err := vmClient.Call(vm.ReceiveMessageMethod, msg, &reply)
-		return reply, err
-	}
-
-	exitCode := 0
-	launchVM := func(logger log.Logger, appOpts servertypes.AppOptions) error {
+	// We need to delegate to our default app for running the actual chain.
+	launchVM := func(logger log.Logger) {
 		args := []string{"ag-chain-cosmos", "--home", gaia.DefaultNodeHome}
 		args = append(args, os.Args[1:]...)
 
-		binary := cast.ToString(appOpts.Get(daemoncmd.FlagSplitVm))
-		if binary == "" {
-			binary, lookErr := FindCosmicSwingsetBinary()
-			if lookErr != nil {
-				return lookErr
-			}
-
-			// We completely delegate to our default app for running the actual chain.
-			logger.Info("agd delegating to JS executable", "binary", binary, "args", args)
-			return syscall.Exec(binary, args, os.Environ())
-		}
-
-		// Split the execution between us and the VM.
-		agdFromVm, vmToAgd, err := os.Pipe()
-		if err != nil {
-			return err
-		}
-		vmFromAgd, agdToVm, err := os.Pipe()
-		if err != nil {
-			return err
-		}
-
-		// Start the command running, then continue.
-		args[0] = binary
-		cmd := NewVMCommand(logger, binary, args, vmFromAgd, vmToAgd)
-		shutdown = makeShutdown(cmd, agdToVm)
-
-		if err := cmd.Start(); err != nil {
-			return err
-		}
-		if vmFromAgd.Close() != nil {
-			return err
-		}
-		if vmToAgd.Close() != nil {
-			return err
+		binary, lookErr := FindCosmicSwingsetBinary()
+		if lookErr != nil {
+			panic(lookErr)
 		}
 
-		// Multiplex bidirectional JSON-RPC over the pipes.
-		agvmConn := jsonrpcconn.NewConn(agdFromVm, agdToVm)
-		clientConn, serverConn := jsonrpcconn.ClientServerConn(agvmConn)
-
-		// Set up the VM server.
-		vmServer := rpc.NewServer()
-		if err := vmServer.RegisterName("agd", vm.NewAgdServer()); err != nil {
-			return err
+		logger.Info("agd delegating to JS executable", "binary", binary, "args", args)
+		execErr := syscall.Exec(binary, args, os.Environ())
+		if execErr != nil {
+			panic(execErr)
 		}
-		go vmServer.ServeCodec(jsonrpc.NewServerCodec(serverConn))
-
-		// Set up the VM client.
-		vmClient = jsonrpc.NewClient(clientConn)
-
-		go func() {
-			// Premature exit from `agd start` should exit the process.
-			_ = cmd.Wait()
-			os.Exit(exitCode)
-		}()
-
-		return nil
 	}
 
+	daemoncmd.OnStartHook = launchVM
 	daemoncmd.OnExportHook = launchVM
-	daemoncmd.OnStartHook = func (logger log.Logger, appOpts servertypes.AppOptions) error {
-		// We tried running start, which should never exit, so exit with non-zero
-		// code if we do.
-		exitCode = 99
-		return launchVM(logger, appOpts)
-	}
 
-	daemon.RunWithController(sendToNode)
+	daemon.RunWithController(nil)
 }

package/cmd/libdaemon/main.go

@@ -10,9 +10,8 @@ package main
 import "C"
 
 import (
-	"context"
 	"encoding/json"
-	"net/rpc"
+	"errors"
 	"os"
 	"path/filepath"
 
@@ -22,7 +21,6 @@ import (
 	"github.com/Agoric/agoric-sdk/golang/cosmos/daemon"
 	daemoncmd "github.com/Agoric/agoric-sdk/golang/cosmos/daemon/cmd"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
-	servertypes "github.com/cosmos/cosmos-sdk/server/types"
 )
 
 type goReturn = struct {
@@ -32,32 +30,8 @@ type goReturn = struct {
 
 const SwingSetPort = 123
 
-var vmClientCodec *vm.ClientCodec
-var agdServer *vm.AgdServer
-
-// ConnectVMClientCodec creates an RPC client codec and a sender to the
-// in-process implementation of the VM.
-func ConnectVMClientCodec(ctx context.Context, nodePort int, sendFunc func(int, int, string)) (*vm.ClientCodec, daemoncmd.Sender) {
-	vmClientCodec = vm.NewClientCodec(context.Background(), sendFunc)
-	vmClient := rpc.NewClientWithCodec(vmClientCodec)
-
-	sendToNode := func(ctx context.Context, needReply bool, str string) (string, error) {
-		if str == "shutdown" {
-			return "", vmClientCodec.Close()
-		}
-
-		msg := vm.Message{
-			Port: nodePort,
-			NeedsReply: needReply,
-			Data: str,
-		}
-		var reply string
-		err := vmClient.Call(vm.ReceiveMessageMethod, msg, &reply)
-		return reply, err
-	}
-
-	return vmClientCodec, sendToNode
-}
+var replies = map[int]chan goReturn{}
+var lastReply = 0
 
 //export RunAgCosmosDaemon
 func RunAgCosmosDaemon(nodePort C.int, toNode C.sendFunc, cosmosArgs []*C.char) C.int {
@@ -68,39 +42,46 @@ func RunAgCosmosDaemon(nodePort C.int, toNode C.sendFunc, cosmosArgs []*C.char)
 
 	gaia.DefaultNodeHome = filepath.Join(userHomeDir, ".ag-chain-cosmos")
 	daemoncmd.AppName = "ag-chain-cosmos"
-	if err := os.Setenv(daemoncmd.EmbeddedVmEnvVar, "libdaemon"); err != nil {
-		panic(err)
-	}
 
-	var sendToNode daemoncmd.Sender
+	// FIXME: Decouple the sending logic from the Cosmos app.
+	sendToNode := func(needReply bool, str string) (string, error) {
+		var rPort int
+		if needReply {
+			lastReply++
+			rPort = lastReply
+			replies[rPort] = make(chan goReturn)
+		}
 
-	sendFunc := func(port int, reply int, str string) {
-		C.invokeSendFunc(toNode, C.int(port), C.int(reply), C.CString(str))
-	}
+		// Send the message
+		C.invokeSendFunc(toNode, nodePort, C.int(rPort), C.CString(str))
+		if !needReply {
+			// Return immediately
+			// fmt.Fprintln(os.Stderr, "Don't wait")
+			return "<no-reply-requested>", nil
+		}
 
-	vmClientCodec, sendToNode = ConnectVMClientCodec(
-		context.Background(),
-		int(nodePort),
-		sendFunc,
-	)
-	agdServer = vm.NewAgdServer()
+		// Block the sending goroutine while we wait for the reply
+		// fmt.Fprintln(os.Stderr, "Waiting for", rPort)
+		ret := <-replies[rPort]
+		delete(replies, rPort)
+		// fmt.Fprintln(os.Stderr, "Woken, got", ret)
+		return ret.str, ret.err
+	}
 
 	args := make([]string, len(cosmosArgs))
 	for i, s := range cosmosArgs {
 		args[i] = C.GoString(s)
 	}
-
 	// fmt.Fprintln(os.Stderr, "Starting Cosmos", args)
 	os.Args = args
 	go func() {
 		// We run in the background, but exit when the job is over.
 		// swingset.SendToNode("hello from Initial Go!")
 		exitCode := 0
-		daemoncmd.OnStartHook = func(logger log.Logger, appOpts servertypes.AppOptions) error {
+		daemoncmd.OnStartHook = func(logger log.Logger) {
 			// We tried running start, which should never exit, so exit with non-zero
 			// code if we ever stop.
 			exitCode = 99
-			return nil
 		}
 		daemon.RunWithController(sendToNode)
 		// fmt.Fprintln(os.Stderr, "Shutting down Cosmos")
@@ -113,10 +94,22 @@ func RunAgCosmosDaemon(nodePort C.int, toNode C.sendFunc, cosmosArgs []*C.char)
 //export ReplyToGo
 func ReplyToGo(replyPort C.int, isError C.int, resp C.Body) C.int {
 	respStr := C.GoString(resp)
-	// fmt.Printf("Reply to Go %d %s\n", replyPort, respStr)
-	if err := vmClientCodec.Receive(int(replyPort), int(isError) != 0, respStr); err != nil {
-		return C.int(1)
+	// fmt.Fprintln(os.Stderr, "Reply to Go", respStr)
+	returnCh := replies[int(replyPort)]
+	if returnCh == nil {
+		// Unexpected reply.
+		// This is okay, since the caller decides whether or
+		// not she wants to listen for replies.
+		return C.int(0)
 	}
+	// Wake up the waiting goroutine
+	ret := goReturn{}
+	if int(isError) == 0 {
+		ret.str = respStr
+	} else {
+		ret.err = errors.New(respStr)
+	}
+	returnCh <- ret
 	return C.int(0)
 }
 
@@ -128,27 +121,20 @@ type errorWrapper struct {
 func SendToGo(port C.int, msg C.Body) C.Body {
 	msgStr := C.GoString(msg)
 	// fmt.Fprintln(os.Stderr, "Send to Go", msgStr)
-	var respStr string
-	message := &vm.Message{
-		Port: int(port),
-		NeedsReply: true,
-		Data: msgStr,
-	}
-	
-	err := agdServer.ReceiveMessage(message, &respStr)
-	if err == nil {
-		return C.CString(respStr)
-	}
-
-	// fmt.Fprintln(os.Stderr, "Cannot receive from controller", err)
-	errResp := errorWrapper{
-		Error: err.Error(),
-	}
-	respBytes, err := json.Marshal(&errResp)
+	respStr, err := vm.ReceiveFromController(int(port), msgStr)
 	if err != nil {
-		panic(err)
+		// fmt.Fprintln(os.Stderr, "Cannot receive from controller", err)
+		errResp := errorWrapper{
+			Error: err.Error(),
+		}
+		respBytes, err := json.Marshal(&errResp)
+		if err != nil {
+			panic(err)
+		}
+		// fmt.Fprintln(os.Stderr, "Marshaled", errResp, respBytes)
+		respStr = string(respBytes)
 	}
-	return C.CString(string(respBytes))
+	return C.CString(respStr)
 }
 
 // Do nothing in main.

package/daemon/cmd/root.go

@@ -1,7 +1,6 @@
 package cmd
 
 import (
-	"context"
 	"errors"
 	"io"
 	"os"
@@ -39,11 +38,11 @@ import (
 )
 
 // Sender is a function that sends a request to the controller.
-type Sender func(ctx context.Context, needReply bool, str string) (string, error)
+type Sender func(needReply bool, str string) (string, error)
 
 var AppName = "agd"
-var OnStartHook func(log.Logger, servertypes.AppOptions) error
-var OnExportHook func(log.Logger, servertypes.AppOptions) error
+var OnStartHook func(logger log.Logger)
+var OnExportHook func(logger log.Logger)
 
 // NewRootCmd creates a new root command for simd. It is called once in the
 // main function.
@@ -61,7 +60,7 @@ func NewRootCmd(sender Sender) (*cobra.Command, params.EncodingConfig) {
 
 	rootCmd := &cobra.Command{
 		Use:   AppName,
-		Short: "Agoric Cosmos App",
+		Short: "Stargate Agoric App",
 		PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
 			// set the default command outputs
 			cmd.SetOut(cmd.OutOrStdout())
@@ -136,9 +135,10 @@ func initRootCmd(sender Sender, rootCmd *cobra.Command, encodingConfig params.En
 	}
 	server.AddCommands(rootCmd, gaia.DefaultNodeHome, ac.newApp, ac.appExport, addModuleInitFlags)
 
+	hasVMController := sender != nil
 	for _, command := range rootCmd.Commands() {
 		if command.Name() == "export" {
-			extendCosmosExportCommand(command)
+			extendCosmosExportCommand(command, hasVMController)
 			break
 		}
 	}
@@ -154,31 +154,8 @@ func initRootCmd(sender Sender, rootCmd *cobra.Command, encodingConfig params.En
 	rootCmd.AddCommand(server.RosettaCommand(encodingConfig.InterfaceRegistry, encodingConfig.Marshaler))
 }
 
-const (
-	// FlagSplitVm is the command-line flag for subcommands that can use a
-	// split-process Agoric VM.  The default is to use an embedded VM.
-	FlagSplitVm = "split-vm"
-	EmbeddedVmEnvVar = "AGD_EMBEDDED_VM"
-)
-
-// hasVMController returns true if we have a VM (are running in split-vm mode,
-// or with an embedded VM).
-func hasVMController(serverCtx *server.Context) bool {
-	return serverCtx.Viper.GetString(FlagSplitVm) != "" ||
-		os.Getenv(EmbeddedVmEnvVar) != ""
-}
-
-func addAgoricVMFlags(cmd *cobra.Command) {
-	cmd.PersistentFlags().String(
-		FlagSplitVm,
-		"",
-		"Specify the external Agoric VM program",
-	)
-}
-
 func addModuleInitFlags(startCmd *cobra.Command) {
 	crisis.AddModuleInitFlags(startCmd)
-	addAgoricVMFlags(startCmd)
 }
 
 func queryCommand() *cobra.Command {
@@ -246,9 +223,7 @@ func (ac appCreator) newApp(
 	appOpts servertypes.AppOptions,
 ) servertypes.Application {
 	if OnStartHook != nil {
-		if err := OnStartHook(logger, appOpts); err != nil {
-			panic(err)
-		}
+		OnStartHook(logger)
 	}
 
 	var cache sdk.MultiStorePersistentCache
@@ -322,9 +297,8 @@ const (
 
 // extendCosmosExportCommand monkey-patches the "export" command added by
 // cosmos-sdk to add a required "export-dir" command-line flag, and create the
-// genesis export in the specified directory if the VM is running.
-func extendCosmosExportCommand(cmd *cobra.Command) {
-	addAgoricVMFlags(cmd)
+// genesis export in the specified directory.
+func extendCosmosExportCommand(cmd *cobra.Command, hasVMController bool) {
 	cmd.Flags().String(FlagExportDir, "", "The directory where to create the genesis export")
 	err := cmd.MarkFlagRequired(FlagExportDir)
 	if err != nil {
@@ -355,28 +329,25 @@ func extendCosmosExportCommand(cmd *cobra.Command) {
 		// current genesis.
 		serverCtx.Viper.Set(gaia.FlagSwingStoreExportDir, swingStoreExportPath)
 
-		if hasVMController(serverCtx) {
-			// Capture the export in the genesisPath.
-			// This will fail if a genesis.json already exists in the export-dir
-			genesisFile, err := os.OpenFile(
-				genesisPath,
-				os.O_CREATE|os.O_EXCL|os.O_WRONLY,
-				os.ModePerm,
-			)
-			if err != nil {
-				return err
-			}
-			defer genesisFile.Close()
-			cmd.SetOut(genesisFile)
+		// This will fail is a genesis.json already exists in the export-dir
+		genesisFile, err := os.OpenFile(genesisPath, os.O_CREATE|os.O_EXCL|os.O_WRONLY, os.ModePerm)
+		if err != nil {
+			return err
 		}
+		defer genesisFile.Close()
+
+		cmd.SetOut(genesisFile)
 
-		// If we don't have a VM, appExport will just use the OnExportHook to exec
-		// the VM program, which will result in reentering this function with the VM
-		// controller set, and activate the above condition.
 		return originalRunE(cmd, args)
 	}
 
-	cmd.RunE = extendedRunE
+	// Only modify the command handler when we have a VM controller to handle
+	// the full export logic. Otherwise, appExport will just exec the VM program
+	// (OnExportHook), which will result in re-entering this flow with the VM
+	// controller set.
+	if hasVMController {
+		cmd.RunE = extendedRunE
+	}
 }
 
 func (ac appCreator) appExport(
@@ -389,9 +360,7 @@ func (ac appCreator) appExport(
 	appOpts servertypes.AppOptions,
 ) (servertypes.ExportedApp, error) {
 	if OnExportHook != nil {
-		if err := OnExportHook(logger, appOpts); err != nil {
-			return servertypes.ExportedApp{}, err
-		}
+		OnExportHook(logger)
 	}
 
 	homePath, ok := appOpts.Get(flags.FlagHome).(string)

package/daemon/main.go

@@ -1,7 +1,6 @@
 package daemon
 
 import (
-	"context"
 	"fmt"
 	"os"
 	"os/signal"
@@ -18,7 +17,7 @@ import (
 )
 
 // DefaultController is a stub controller.
-var DefaultController = func(ctx context.Context, needReply bool, str string) (string, error) {
+var DefaultController = func(needReply bool, str string) (string, error) {
 	return "", fmt.Errorf("Controller not configured; did you mean to use `ag-chain-cosmos` instead?")
 }
 
@@ -35,7 +34,6 @@ func RunWithController(sendToController cmd.Sender) {
 	signal.Notify(sigs, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
 	go func() {
 		<-sigs
-		_, _ = sendToController(context.Background(), false, "shutdown")
 		os.Exit(98)
 	}()
 

package/git-revision.txt

@@ -1 +1 @@
-5dc325b
+26244e8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/cosmos",
-  "version": "0.34.2-dev-5dc325b.0+5dc325b",
+  "version": "0.35.0-getting-started-dev-26244e8.0+26244e8",
   "description": "Connect JS to the Cosmos blockchain SDK",
   "parsers": {
     "js": "mjs"
@@ -19,7 +19,7 @@
     "postpack": "git clean -f git-revision.txt",
     "build": "exit 0",
     "lint-fix": "yarn lint:eslint --fix",
-    "lint": "exit 0"
+    "lint": "eslint '**/*.{cjs,js}'"
   },
   "dependencies": {
     "bindings": "^1.2.1",
@@ -35,8 +35,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "typeCoverage": {
-    "atLeast": 0
-  },
-  "gitHead": "5dc325b8cc1d94f46ecc18a7c67a14989feade11"
+  "gitHead": "26244e821f1a83cd5868f0c7d54aa480c8c17e5e"
 }