@agoric/cosmos 0.35.0-u15.0 → 0.35.0-u16.1

package/daemon/cmd/root.go

@@ -1,15 +1,14 @@
 package cmd
 
 import (
-	"context"
 	"errors"
+	"fmt"
 	"io"
 	"os"
 	"path/filepath"
 
 	serverconfig "github.com/cosmos/cosmos-sdk/server/config"
 
-	"github.com/cosmos/cosmos-sdk/baseapp"
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/config"
 	"github.com/cosmos/cosmos-sdk/client/debug"
@@ -20,9 +19,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/client/snapshot"
 	"github.com/cosmos/cosmos-sdk/server"
 	servertypes "github.com/cosmos/cosmos-sdk/server/types"
-	"github.com/cosmos/cosmos-sdk/snapshots"
-	snapshottypes "github.com/cosmos/cosmos-sdk/snapshots/types"
-	"github.com/cosmos/cosmos-sdk/store"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	authcmd "github.com/cosmos/cosmos-sdk/x/auth/client/cli"
 	"github.com/cosmos/cosmos-sdk/x/auth/types"
@@ -39,18 +35,17 @@ import (
 
 	gaia "github.com/Agoric/agoric-sdk/golang/cosmos/app"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/app/params"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+	swingsetkeeper "github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/keeper"
 )
 
-// Sender is a function that sends a request to the controller.
-type Sender func(ctx context.Context, 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(*vm.AgdServer, log.Logger, servertypes.AppOptions) error
+var OnExportHook func(*vm.AgdServer, log.Logger, servertypes.AppOptions) error
 
 // NewRootCmd creates a new root command for simd. It is called once in the
 // main function.
-func NewRootCmd(sender Sender) (*cobra.Command, params.EncodingConfig) {
+func NewRootCmd(sender vm.Sender) (*cobra.Command, params.EncodingConfig) {
 	encodingConfig := gaia.MakeEncodingConfig()
 	initClientCtx := client.Context{}.
 		WithCodec(encodingConfig.Marshaler).
@@ -124,13 +119,14 @@ func initAppConfig() (string, interface{}) {
 	return serverconfig.DefaultConfigTemplate, *srvCfg
 }
 
-func initRootCmd(sender Sender, rootCmd *cobra.Command, encodingConfig params.EncodingConfig) {
+func initRootCmd(sender vm.Sender, rootCmd *cobra.Command, encodingConfig params.EncodingConfig) {
 	cfg := sdk.GetConfig()
 	cfg.Seal()
 
 	ac := appCreator{
-		encCfg: encodingConfig,
-		sender: sender,
+		encCfg:    encodingConfig,
+		sender:    sender,
+		agdServer: vm.NewAgdServer(),
 	}
 
 	rootCmd.AddCommand(
@@ -144,17 +140,27 @@ func initRootCmd(sender Sender, rootCmd *cobra.Command, encodingConfig params.En
 		testnetCmd(gaia.ModuleBasics, banktypes.GenesisBalancesIterator{}),
 		debug.Cmd(),
 		config.Cmd(),
-		pruning.Cmd(ac.newApp, gaia.DefaultNodeHome),
-		snapshot.Cmd(ac.newApp),
+		pruning.Cmd(ac.newSnapshotsApp, gaia.DefaultNodeHome),
+		snapshot.Cmd(ac.newSnapshotsApp),
 	)
 
 	server.AddCommands(rootCmd, gaia.DefaultNodeHome, ac.newApp, ac.appExport, addModuleInitFlags)
 
-	hasVMController := sender != nil
 	for _, command := range rootCmd.Commands() {
-		if command.Name() == "export" {
-			extendCosmosExportCommand(command, hasVMController)
-			break
+		switch command.Name() {
+		case "export":
+			addAgoricVMFlags(command)
+			extendCosmosExportCommand(command)
+		case "snapshots":
+			for _, subCommand := range command.Commands() {
+				switch subCommand.Name() {
+				case "restore":
+					addAgoricVMFlags(subCommand)
+				case "export":
+					addAgoricVMFlags(subCommand)
+					replaceCosmosSnapshotExportCommand(subCommand, ac)
+				}
+			}
 		}
 	}
 
@@ -169,7 +175,30 @@ 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) {
+	addAgoricVMFlags(startCmd)
 }
 
 func queryCommand() *cobra.Command {
@@ -227,8 +256,9 @@ func txCommand() *cobra.Command {
 }
 
 type appCreator struct {
-	encCfg params.EncodingConfig
-	sender Sender
+	encCfg    params.EncodingConfig
+	sender    vm.Sender
+	agdServer *vm.AgdServer
 }
 
 func (ac appCreator) newApp(
@@ -238,27 +268,18 @@ func (ac appCreator) newApp(
 	appOpts servertypes.AppOptions,
 ) servertypes.Application {
 	if OnStartHook != nil {
-		if err := OnStartHook(logger, appOpts); err != nil {
+		if err := OnStartHook(ac.agdServer, logger, appOpts); err != nil {
 			panic(err)
 		}
 	}
 
-	var cache sdk.MultiStorePersistentCache
-
-	if cast.ToBool(appOpts.Get(server.FlagInterBlockCache)) {
-		cache = store.NewCommitKVStoreCacheManager()
-	}
+	baseappOptions := server.DefaultBaseappOptions(appOpts)
 
 	skipUpgradeHeights := make(map[int64]bool)
 	for _, h := range cast.ToIntSlice(appOpts.Get(server.FlagUnsafeSkipUpgrades)) {
 		skipUpgradeHeights[int64(h)] = true
 	}
 
-	pruningOpts, err := server.GetPruningOptionsFromFlags(appOpts)
-	if err != nil {
-		panic(err)
-	}
-
 	homePath := cast.ToString(appOpts.Get(flags.FlagHome))
 
 	// Set a default value for FlagSwingStoreExportDir based on the homePath
@@ -268,36 +289,41 @@ func (ac appCreator) newApp(
 		viper.Set(gaia.FlagSwingStoreExportDir, filepath.Join(homePath, "config", ExportedSwingStoreDirectoryName))
 	}
 
-	snapshotDir := filepath.Join(homePath, "data", "snapshots")
-	snapshotDB, err := sdk.NewLevelDB("metadata", snapshotDir)
-	if err != nil {
-		panic(err)
-	}
-	snapshotStore, err := snapshots.NewStore(snapshotDB, snapshotDir)
-	if err != nil {
-		panic(err)
-	}
-	snapshotOptions := snapshottypes.NewSnapshotOptions(
-		cast.ToUint64(appOpts.Get(server.FlagStateSyncSnapshotInterval)),
-		cast.ToUint32(appOpts.Get(server.FlagStateSyncSnapshotKeepRecent)),
+	return gaia.NewAgoricApp(
+		ac.sender, ac.agdServer,
+		logger, db, traceStore, true, skipUpgradeHeights,
+		homePath,
+		cast.ToUint(appOpts.Get(server.FlagInvCheckPeriod)),
+		ac.encCfg,
+		appOpts,
+		baseappOptions...,
 	)
+}
+
+func (ac appCreator) newSnapshotsApp(
+	logger log.Logger,
+	db dbm.DB,
+	traceStore io.Writer,
+	appOpts servertypes.AppOptions,
+) servertypes.Application {
+	if OnExportHook != nil {
+		if err := OnExportHook(ac.agdServer, logger, appOpts); err != nil {
+			panic(err)
+		}
+	}
+
+	baseappOptions := server.DefaultBaseappOptions(appOpts)
+
+	homePath := cast.ToString(appOpts.Get(flags.FlagHome))
 
 	return gaia.NewAgoricApp(
-		ac.sender,
-		logger, db, traceStore, true, skipUpgradeHeights,
+		ac.sender, ac.agdServer,
+		logger, db, traceStore, true, map[int64]bool{},
 		homePath,
 		cast.ToUint(appOpts.Get(server.FlagInvCheckPeriod)),
 		ac.encCfg,
 		appOpts,
-		baseapp.SetPruning(pruningOpts),
-		baseapp.SetMinGasPrices(cast.ToString(appOpts.Get(server.FlagMinGasPrices))),
-		baseapp.SetHaltHeight(cast.ToUint64(appOpts.Get(server.FlagHaltHeight))),
-		baseapp.SetHaltTime(cast.ToUint64(appOpts.Get(server.FlagHaltTime))),
-		baseapp.SetMinRetainBlocks(cast.ToUint64(appOpts.Get(server.FlagMinRetainBlocks))),
-		baseapp.SetInterBlockCache(cache),
-		baseapp.SetTrace(cast.ToBool(appOpts.Get(server.FlagTrace))),
-		baseapp.SetIndexEvents(cast.ToStringSlice(appOpts.Get(server.FlagIndexEvents))),
-		baseapp.SetSnapshot(snapshotStore, snapshotOptions),
+		baseappOptions...,
 	)
 }
 
@@ -316,8 +342,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.
-func extendCosmosExportCommand(cmd *cobra.Command, hasVMController bool) {
+// genesis export in the specified directory if the VM is running.
+func extendCosmosExportCommand(cmd *cobra.Command) {
 	cmd.Flags().String(FlagExportDir, "", "The directory where to create the genesis export")
 	err := cmd.MarkFlagRequired(FlagExportDir)
 	if err != nil {
@@ -348,25 +374,28 @@ func extendCosmosExportCommand(cmd *cobra.Command, hasVMController bool) {
 		// current genesis.
 		serverCtx.Viper.Set(gaia.FlagSwingStoreExportDir, swingStoreExportPath)
 
-		// 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
+		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)
 		}
-		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)
 	}
 
-	// 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
-	}
+	cmd.RunE = extendedRunE
 }
 
 func (ac appCreator) appExport(
@@ -379,7 +408,7 @@ func (ac appCreator) appExport(
 	appOpts servertypes.AppOptions,
 ) (servertypes.ExportedApp, error) {
 	if OnExportHook != nil {
-		if err := OnExportHook(logger, appOpts); err != nil {
+		if err := OnExportHook(ac.agdServer, logger, appOpts); err != nil {
 			return servertypes.ExportedApp{}, err
 		}
 	}
@@ -395,7 +424,7 @@ func (ac appCreator) appExport(
 	}
 
 	gaiaApp := gaia.NewAgoricApp(
-		ac.sender,
+		ac.sender, ac.agdServer,
 		logger,
 		db,
 		traceStore,
@@ -415,3 +444,64 @@ func (ac appCreator) appExport(
 
 	return gaiaApp.ExportAppStateAndValidators(forZeroHeight, jailAllowedAddrs)
 }
+
+// replaceCosmosSnapshotExportCommand monkey-patches the "snapshots export" command
+// added by cosmos-sdk and replaces its implementation with one suitable for
+// our modifications to the cosmos snapshots process
+func replaceCosmosSnapshotExportCommand(cmd *cobra.Command, ac appCreator) {
+	// Copy of RunE is cosmos-sdk/client/snapshot/export.go
+	replacedRunE := func(cmd *cobra.Command, args []string) error {
+		ctx := server.GetServerContextFromCmd(cmd)
+
+		heightFlag, err := cmd.Flags().GetInt64("height")
+		if err != nil {
+			return err
+		}
+
+		home := ctx.Config.RootDir
+		dataDir := filepath.Join(home, "data")
+		db, err := dbm.NewDB("application", server.GetAppDBBackend(ctx.Viper), dataDir)
+		if err != nil {
+			return err
+		}
+
+		app := ac.newSnapshotsApp(ctx.Logger, db, nil, ctx.Viper)
+		gaiaApp := app.(*gaia.GaiaApp)
+
+		latestHeight := app.CommitMultiStore().LastCommitID().Version
+
+		if heightFlag != 0 && latestHeight != heightFlag {
+			return fmt.Errorf("cannot export at height %d, only latest height %d is supported", heightFlag, latestHeight)
+		}
+
+		cmd.Printf("Exporting snapshot for height %d\n", latestHeight)
+
+		err = gaiaApp.SwingSetSnapshotter.InitiateSnapshot(latestHeight)
+		if err != nil {
+			return err
+		}
+
+		err = swingsetkeeper.WaitUntilSwingStoreExportDone()
+		if err != nil {
+			return err
+		}
+
+		snapshotList, err := app.SnapshotManager().List()
+		if err != nil {
+			return err
+		}
+
+		snapshotHeight := uint64(latestHeight)
+
+		for _, snapshot := range snapshotList {
+			if snapshot.Height == snapshotHeight {
+				cmd.Printf("Snapshot created at height %d, format %d, chunks %d\n", snapshot.Height, snapshot.Format, snapshot.Chunks)
+				break
+			}
+		}
+
+		return nil
+	}
+
+	cmd.RunE = replacedRunE
+}

package/daemon/cmd/root_test.go

@@ -1,13 +1,24 @@
 package cmd_test
 
 import (
+	"bytes"
+	"io"
+	"os"
 	"testing"
+	"text/template"
 
+	"github.com/spf13/pflag"
+	"github.com/stretchr/testify/require"
+
+	"github.com/cosmos/cosmos-sdk/server"
 	svrcmd "github.com/cosmos/cosmos-sdk/server/cmd"
+	serverconfig "github.com/cosmos/cosmos-sdk/server/config"
+	servertypes "github.com/cosmos/cosmos-sdk/server/types"
+	"github.com/tendermint/tendermint/libs/log"
+	dbm "github.com/tendermint/tm-db"
 
 	app "github.com/Agoric/agoric-sdk/golang/cosmos/app"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/daemon/cmd"
-	"github.com/stretchr/testify/require"
 )
 
 func TestRootCmdConfig(t *testing.T) {
@@ -21,3 +32,180 @@ func TestRootCmdConfig(t *testing.T) {
 
 	require.NoError(t, svrcmd.Execute(rootCmd, "", app.DefaultNodeHome))
 }
+
+func TestCLIFlags(t *testing.T) {
+	// List of flags we have so far observed as used by the base cosmos sdk
+	// Before adding any flag to this list, the author should audit if explicit
+	// handling should not be added in the Agoric app (most likely in root.go)
+	expectedFlagNames := map[string]interface{}{
+		"abci":                  "",
+		"abci-client-type":      "",
+		"address":               "",
+		"app-db-backend":        "",
+		"cpu-profile":           "",
+		"db_backend":            "",
+		"db_dir":                "",
+		"fast_sync":             "",
+		"genesis_hash":          "",
+		"grpc-only":             "",
+		"halt-height":           "",
+		"halt-time":             "",
+		"home":                  "",
+		"iavl-cache-size":       "",
+		"iavl-disable-fastnode": "",
+		"iavl-lazy-loading":     "",
+		"index-events":          "",
+		"inter-block-cache":     "",
+		"inv-check-period":      "",
+		"min-retain-blocks":     "",
+		"minimum-gas-prices":    "",
+		"moniker":               "",
+		"priv_validator_laddr":  "",
+		"proxy_app":             "",
+		"pruning":               "default",
+		"pruning-interval":      "",
+		"pruning-keep-recent":   "",
+		"trace":                 "",
+		"trace-store":           "",
+		"transport":             "",
+		"unsafe-skip-upgrades":  "",
+		"with-tendermint":       "",
+
+		"api.address":              "",
+		"api.enable":               "",
+		"api.enabled-unsafe-cors":  "",
+		"api.max-open-connections": "",
+		"api.rpc-max-body-bytes":   "",
+		"api.rpc-read-timeout":     "",
+		"api.rpc-write-timeout":    "",
+		"api.swagger":              "",
+
+		"consensus.create_empty_blocks":          "",
+		"consensus.create_empty_blocks_interval": "",
+		"consensus.double_sign_check_height":     "",
+
+		"grpc-web.address":            "",
+		"grpc-web.enable":             "",
+		"grpc-web.enable-unsafe-cors": "",
+
+		"grpc.address":           "",
+		"grpc.enable":            "",
+		"grpc.max-recv-msg-size": "",
+		"grpc.max-send-msg-size": "",
+
+		"p2p.external-address":       "",
+		"p2p.laddr":                  "",
+		"p2p.persistent_peers":       "",
+		"p2p.pex":                    "",
+		"p2p.private_peer_ids":       "",
+		"p2p.seed_mode":              "",
+		"p2p.seeds":                  "",
+		"p2p.unconditional_peer_ids": "",
+		"p2p.upnp":                   "",
+
+		"rpc.grpc_laddr":  "",
+		"rpc.laddr":       "",
+		"rpc.pprof_laddr": "",
+		"rpc.unsafe":      "",
+
+		"rosetta.address":               "",
+		"rosetta.blockchain":            "",
+		"rosetta.denom-to-suggest":      "",
+		"rosetta.enable-fee-suggestion": "",
+		"rosetta.enable":                "",
+		"rosetta.gas-to-suggest":        "",
+		"rosetta.network":               "",
+		"rosetta.offline":               "",
+		"rosetta.retries":               "",
+
+		"state-sync.snapshot-interval":    "",
+		"state-sync.snapshot-keep-recent": "",
+
+		"store.streamers": "",
+
+		"streamers.file.fsync":              "",
+		"streamers.file.keys":               "",
+		"streamers.file.output-metadata":    "",
+		"streamers.file.prefix":             "",
+		"streamers.file.stop-node-on-error": "",
+		"streamers.file.write_dir":          "",
+
+		"telemetry.enable-hostname-label":     "",
+		"telemetry.enable-hostname":           "",
+		"telemetry.enable-service-label":      "",
+		"telemetry.enabled":                   "",
+		"telemetry.global-labels":             "",
+		"telemetry.prometheus-retention-time": "",
+		"telemetry.service-name":              "",
+	}
+	unknownFlagNames := []string{}
+	missingFlagNames := map[string]bool{}
+	for name := range expectedFlagNames {
+		missingFlagNames[name] = true
+	}
+	readFlag := func(name string) interface{} {
+		if defaultValue, found := expectedFlagNames[name]; found {
+			delete(missingFlagNames, name)
+			return defaultValue
+		}
+		unknownFlagNames = append(unknownFlagNames, name)
+		return nil
+	}
+
+	homeDir, err := os.MkdirTemp("", "cosmos-sdk-home")
+	if err != nil {
+		panic(err)
+	}
+	defer os.RemoveAll(homeDir)
+
+	// First get the command line flags that the base cosmos-sdk defines
+	dummyAppCreator := func(
+		logger log.Logger,
+		db dbm.DB,
+		traceStore io.Writer,
+		appOpts servertypes.AppOptions,
+	) servertypes.Application {
+		return new(app.GaiaApp)
+	}
+	cmd := server.StartCmd(dummyAppCreator, homeDir)
+	flags := cmd.Flags()
+	flags.SortFlags = true
+	flags.VisitAll(func(flag *pflag.Flag) {
+		readFlag(flag.Name)
+	})
+
+	// Then get the options parsing the default config file.
+	serverCtx := server.NewDefaultContext()
+	// appTemplate, appConfig := initAppConfig()
+	appTemplate := serverconfig.DefaultConfigTemplate
+	appConfig := serverconfig.DefaultConfig()
+	configTemplate := template.Must(template.New("").Parse(appTemplate))
+	var buffer bytes.Buffer
+	if err := configTemplate.Execute(&buffer, appConfig); err != nil {
+		panic(err)
+	}
+	serverCtx.Viper.SetConfigType("toml")
+	if err := serverCtx.Viper.MergeConfig(&buffer); err != nil {
+		panic(err)
+	}
+	for _, configKey := range serverCtx.Viper.AllKeys() {
+		readFlag(configKey)
+	}
+
+	if len(unknownFlagNames) != 0 {
+		t.Error(
+			"unknown CLI flags in cosmos-sdk; incorporate as needed and update this test",
+			unknownFlagNames,
+		)
+	}
+	if len(missingFlagNames) != 0 {
+		missing := []string{}
+		for name := range missingFlagNames {
+			missing = append(missing, name)
+		}
+		t.Error(
+			"expected CLI flags missing from cosmos-sdk; remove from this test",
+			missing,
+		)
+	}
+}

package/daemon/main.go

@@ -13,12 +13,13 @@ import (
 	"github.com/Agoric/agoric-sdk/golang/cosmos/agoric"
 	app "github.com/Agoric/agoric-sdk/golang/cosmos/app"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/daemon/cmd"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
 // DefaultController is a stub controller.
-var DefaultController = func(ctx context.Context, needReply bool, str string) (string, error) {
+var DefaultController vm.Sender = func(ctx context.Context, needReply bool, jsonRequest string) (jsonReply string, err error) {
 	return "", fmt.Errorf("Controller not configured; did you mean to use `ag-chain-cosmos` instead?")
 }
 
@@ -28,13 +29,14 @@ func Run() {
 }
 
 // RunWithController starts the app with a custom upcall handler.
-func RunWithController(sendToController cmd.Sender) {
+func RunWithController(sendToController vm.Sender) {
 	// Exit on Control-C and kill.
 	// Without this explicitly, ag-chain-cosmos ignores them.
 	sigs := make(chan os.Signal, 1)
 	signal.Notify(sigs, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
 	go func() {
 		<-sigs
+		_, _ = sendToController(context.Background(), false, "shutdown")
 		os.Exit(98)
 	}()
 

package/e2e_test/Makefile

@@ -0,0 +1,29 @@
+# It is possible to use environment variables to change how the tests run
+# - `E2ETEST_CHAINNAME0` - set to `"agoric"`, `"gaia"`, or another chain known by interchaintest to choose which chain runs as the first chain
+# - `E2ETEST_CHAINNAME1` - set to `"agoric"`, `"gaia"`, or another chain known by interchaintest to choose which chain runs as the second chain
+# - `E2ETEST_CHAINNAME2` - set to `"agoric"`, `"gaia"`, or another chain known by interchaintest to choose which chain runs as the third chain
+# - `E2ETEST_CHAINNAME3` - set to `"agoric"`, `"gaia"`, or another chain known by interchaintest to choose which chain runs as the fourth chain
+# - `E2ETEST_CHAINIMAGE_AGORIC` - the value of this will be used specific the repository & version of docker image to use for the agoric chain. a valid value must have a semicolon and be formatted as `repository:tag`. ex: `E2ETEST_CHAINIMAGE_AGORIC="ghcr.io/agoric/agoricinterchain:latest"`
+# - `E2ETEST_RELAYERNAME` - set to `"cosmos"` or `"hermes"` to choose the relayer type
+# - `E2ETEST_BLOCKS_TO_WAIT` - set to a number to control how many blocks to wait for an ACK from an IBC transfer and how many blocks to wait for TX settlement.
+all: TestConformance TestPFM
+
+# build - Sanity compile the tests
+build:
+	go test -c -o ./bin/agoricinterchaintest
+
+# TestPFM - use 4 chains to test PFM
+TestPFM:
+	# Add a 20min timeout since tests are slow
+	# Add failfast since each test depends on the next
+	go test -failfast -timeout 20m -v -run ^TestPFM
+
+# TestConformance - use 2 chains to test basic IBC conformance
+TestConformance:
+	# Add a 20min timeout since tests are slow
+	go test -timeout 20m -v -run ^TestConformance
+
+# TestChainPair - Minimal version of TestConformance does less permutations
+TestChainPair:
+	# Add a 20min timeout since tests are slow
+	go test -timeout 20m -v -run ^TestChainPair