@agoric/cosmos 0.34.2-orchestration-dev-096c4e8.0 → 0.34.2-other-dev-3eb1a1d.0

package/app/upgrade.go

@@ -0,0 +1,248 @@
+package gaia
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"text/template"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+	swingsetkeeper "github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/keeper"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/module"
+	upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types"
+)
+
+var upgradeNamesOfThisVersion = []string{
+	"UNRELEASED_BASIC", // no-frills
+	"UNRELEASED_A3P_INTEGRATION",
+	"UNRELEASED_main",
+	"UNRELEASED_devnet",
+	"UNRELEASED_emerynet",
+	"UNRELEASED_REAPPLY",
+}
+
+// isUpgradeNameOfThisVersion returns whether the provided plan name is a
+// known upgrade name of this software version
+func isUpgradeNameOfThisVersion(name string) bool {
+	for _, upgradeName := range upgradeNamesOfThisVersion {
+		if upgradeName == name {
+			return true
+		}
+	}
+	return false
+}
+
+// validUpgradeName is an identity function that asserts the provided name
+// is an upgrade name of this software version. It can be used as a sort of
+// dynamic enum check.
+func validUpgradeName(name string) string {
+	if !isUpgradeNameOfThisVersion(name) {
+		panic(fmt.Errorf("invalid upgrade name: %s", name))
+	}
+	return name
+}
+
+// isPrimaryUpgradeName returns wether the provided plan name is considered a
+// primary for the purpose of applying store migrations for the first upgrade
+// of this version.
+// It is expected that only primary plan names are used for non testing chains.
+func isPrimaryUpgradeName(name string) bool {
+	if name == "" {
+		// An empty upgrade name can happen if there are no upgrade in progress
+		return false
+	}
+	switch name {
+	case validUpgradeName("UNRELEASED_BASIC"),
+		validUpgradeName("UNRELEASED_A3P_INTEGRATION"),
+		validUpgradeName("UNRELEASED_main"),
+		validUpgradeName("UNRELEASED_devnet"),
+		validUpgradeName("UNRELEASED_emerynet"):
+		return true
+	case validUpgradeName("UNRELEASED_REAPPLY"):
+		return false
+	default:
+		panic(fmt.Errorf("unexpected upgrade name %s", validUpgradeName(name)))
+	}
+}
+
+// isFirstTimeUpgradeOfThisVersion looks up in the upgrade store whether no
+// upgrade plan name of this version have previously been applied.
+func isFirstTimeUpgradeOfThisVersion(app *GaiaApp, ctx sdk.Context) bool {
+	for _, name := range upgradeNamesOfThisVersion {
+		if app.UpgradeKeeper.GetDoneHeight(ctx, name) != 0 {
+			return false
+		}
+	}
+	return true
+}
+
+func buildProposalStepWithArgs(moduleName string, entrypoint string, opts map[string]any) (vm.CoreProposalStep, error) {
+	t := template.Must(template.New("").Parse(`{
+		"module": "{{.moduleName}}",
+		"entrypoint": "{{.entrypoint}}",
+		"args": [ {{.optsArg}} ]
+	}`))
+
+	optsArg, err := json.Marshal(opts)
+	if err != nil {
+		return nil, err
+	}
+
+	var result strings.Builder
+	err = t.Execute(&result, map[string]any{
+		"moduleName": moduleName,
+		"entrypoint": entrypoint,
+		"optsArg":    string(optsArg),
+	})
+	if err != nil {
+		return nil, err
+	}
+	jsonStr := result.String()
+	jsonBz := []byte(jsonStr)
+	if !json.Valid(jsonBz) {
+		return nil, fmt.Errorf("invalid JSON: %s", jsonStr)
+	}
+	proposal := vm.ArbitraryCoreProposal{Json: jsonBz}
+	return vm.CoreProposalStepForModules(proposal), nil
+}
+
+func getVariantFromUpgradeName(upgradeName string) string {
+	switch upgradeName {
+	case "UNRELEASED_A3P_INTEGRATION":
+		return "A3P_INTEGRATION"
+	case "UNRELEASED_main":
+		return "MAINNET"
+	case "UNRELEASED_devnet":
+		return "DEVNET"
+	case "UNRELEASED_emerynet":
+		return "EMERYNET"
+		// Noupgrade for this version.
+	case "UNRELEASED_BASIC":
+		return ""
+	default:
+		return ""
+	}
+}
+
+func replaceElectorateCoreProposalStep(upgradeName string) (vm.CoreProposalStep, error) {
+	variant := getVariantFromUpgradeName(upgradeName)
+
+	if variant == "" {
+		return nil, nil
+	}
+
+	return buildProposalStepWithArgs(
+		"@agoric/builders/scripts/inter-protocol/replace-electorate-core.js",
+		"defaultProposalBuilder",
+		map[string]any{
+			"variant": variant,
+		},
+	)
+}
+
+func replacePriceFeedsCoreProposal(upgradeName string) (vm.CoreProposalStep, error) {
+	variant := getVariantFromUpgradeName(upgradeName)
+
+	if variant == "" {
+		return nil, nil
+	}
+
+	return buildProposalStepWithArgs(
+		"@agoric/builders/scripts/inter-protocol/updatePriceFeeds.js",
+		"defaultProposalBuilder",
+		map[string]any{
+			"variant": variant,
+		},
+	)
+}
+
+// unreleasedUpgradeHandler performs standard upgrade actions plus custom actions for the unreleased upgrade.
+func unreleasedUpgradeHandler(app *GaiaApp, targetUpgrade string) func(sdk.Context, upgradetypes.Plan, module.VersionMap) (module.VersionMap, error) {
+	return func(ctx sdk.Context, plan upgradetypes.Plan, fromVm module.VersionMap) (module.VersionMap, error) {
+		app.CheckControllerInited(false)
+
+		CoreProposalSteps := []vm.CoreProposalStep{}
+
+		// These CoreProposalSteps are not idempotent and should only be executed
+		// as part of the first upgrade using this handler on any given chain.
+		if isFirstTimeUpgradeOfThisVersion(app, ctx) {
+			// The storeUpgrades defined in app.go only execute for the primary upgrade name
+			// If we got here and this first upgrade of this version does not use the
+			// primary upgrade name, stores have not been initialized correctly.
+			if !isPrimaryUpgradeName(plan.Name) {
+				return module.VersionMap{}, fmt.Errorf("cannot run %s as first upgrade", plan.Name)
+			}
+
+			replaceElectorateStep, err := replaceElectorateCoreProposalStep(targetUpgrade)
+			if err != nil {
+				return nil, err
+			} else if replaceElectorateStep != nil {
+				CoreProposalSteps = append(CoreProposalSteps, replaceElectorateStep)
+			}
+
+			priceFeedUpdate, err := replacePriceFeedsCoreProposal(targetUpgrade)
+			if err != nil {
+				return nil, err
+			} else if priceFeedUpdate != nil {
+				CoreProposalSteps = append(CoreProposalSteps,
+					priceFeedUpdate,
+					// The following have a dependency onto the price feed proposal
+					vm.CoreProposalStepForModules(
+						"@agoric/builders/scripts/vats/add-auction.js",
+					),
+					vm.CoreProposalStepForModules(
+						"@agoric/builders/scripts/vats/upgradeVaults.js",
+					),
+				)
+			}
+
+			// Each CoreProposalStep runs sequentially, and can be constructed from
+			// one or more modules executing in parallel within the step.
+			CoreProposalSteps = append(CoreProposalSteps,
+				vm.CoreProposalStepForModules(
+					// Upgrade Zoe (no new ZCF needed).
+					"@agoric/builders/scripts/vats/upgrade-zoe.js",
+				),
+				// Revive KREAd characters
+				vm.CoreProposalStepForModules(
+					"@agoric/builders/scripts/vats/revive-kread.js",
+				),
+				vm.CoreProposalStepForModules(
+					// Upgrade to include a cleanup from https://github.com/Agoric/agoric-sdk/pull/10319
+					"@agoric/builders/scripts/smart-wallet/build-wallet-factory2-upgrade.js",
+				),
+			)
+
+			// CoreProposals for Upgrade 19
+			CoreProposalSteps = append(CoreProposalSteps,
+				vm.CoreProposalStepForModules(
+					"@agoric/builders/scripts/inter-protocol/replace-feeDistributor.js",
+				),
+			)
+		}
+
+		app.upgradeDetails = &upgradeDetails{
+			// Record the plan to send to SwingSet
+			Plan: plan,
+			// Core proposals that should run during the upgrade block
+			// These will be merged with any coreProposals specified in the
+			// upgradeInfo field of the upgrade plan ran as subsequent steps
+			CoreProposals: vm.CoreProposalsFromSteps(CoreProposalSteps...),
+		}
+
+		// Always run module migrations
+		mvm, err := app.mm.RunMigrations(ctx, app.configurator, fromVm)
+		if err != nil {
+			return mvm, err
+		}
+
+		m := swingsetkeeper.NewMigrator(app.SwingSetKeeper)
+		err = m.MigrateParams(ctx)
+		if err != nil {
+			return mvm, err
+		}
+
+		return mvm, nil
+	}
+}

package/cmd/agd/agvm.go

@@ -27,9 +27,9 @@ func NewVMCommand(logger log.Logger, binary string, args []string, vmFromAgd, vm
 	fdToAgd := fdFromAgd + 1
 
 	// ExtraFiles begins at fd numStdFiles, so we need to compute the array.
-	cmd.ExtraFiles = make([]*os.File, fdToAgd - numStdFiles + 1)
-	cmd.ExtraFiles[fdFromAgd - numStdFiles] = vmFromAgd
-	cmd.ExtraFiles[fdToAgd - numStdFiles] = vmToAgd
+	cmd.ExtraFiles = make([]*os.File, fdToAgd-numStdFiles+1)
+	cmd.ExtraFiles[fdFromAgd-numStdFiles] = vmFromAgd
+	cmd.ExtraFiles[fdToAgd-numStdFiles] = vmToAgd
 
 	// Pass the file descriptor numbers in the environment.
 	cmd.Env = append(

package/cmd/agd/find_binary.go

@@ -8,7 +8,7 @@ import (
 
 // FindBinaryNextToMe looks for binName next to the current executable.
 // It returns an absolute filename for binName, or an error.
-func FindBinaryNextToMe(walkUp int, path... string) (string, error) {
+func FindBinaryNextToMe(walkUp int, path ...string) (string, error) {
 	ex, err := os.Executable()
 	if err != nil {
 		return "", err
@@ -32,7 +32,7 @@ func FindBinaryNextToMe(walkUp int, path... string) (string, error) {
 	if _, err = os.Stat(bin); err != nil {
 		return "", err
 	}
-	
+
 	return bin, nil
 }
 

package/cmd/agd/main.go

@@ -49,7 +49,6 @@ func makeShutdown(cmd *exec.Cmd, writer *os.File) func() error {
 	}
 }
 
-
 // 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.
@@ -58,12 +57,12 @@ func main() {
 	var shutdown func() error
 
 	nodePort := 1
-	sendToNode := func(ctx context.Context, needReply bool, str string) (string, error) {
+	var sendToNode vm.Sender = func(ctx context.Context, needReply bool, jsonRequest string) (jsonReply string, err error) {
 		if vmClient == nil {
 			return "", errors.New("sendToVM called without VM client set up")
 		}
 
-		if str == "shutdown" {
+		if jsonRequest == "shutdown" {
 			// We could ask nicely, but don't bother.
 			if shutdown != nil {
 				return "", shutdown()
@@ -72,17 +71,17 @@ func main() {
 		}
 
 		msg := vm.Message{
-			Port: nodePort,
+			Port:       nodePort,
 			NeedsReply: needReply,
-			Data: str,
+			Data:       jsonRequest,
 		}
 		var reply string
-		err := vmClient.Call(vm.ReceiveMessageMethod, msg, &reply)
+		err = vmClient.Call(vm.ReceiveMessageMethod, msg, &reply)
 		return reply, err
 	}
 
 	exitCode := 0
-	launchVM := func(logger log.Logger, appOpts servertypes.AppOptions) error {
+	launchVM := func(agdServer *vm.AgdServer, logger log.Logger, appOpts servertypes.AppOptions) error {
 		args := []string{"ag-chain-cosmos", "--home", gaia.DefaultNodeHome}
 		args = append(args, os.Args[1:]...)
 
@@ -129,7 +128,7 @@ func main() {
 
 		// Set up the VM server.
 		vmServer := rpc.NewServer()
-		if err := vmServer.RegisterName("agd", vm.NewAgdServer()); err != nil {
+		if err := vmServer.RegisterName("agd", agdServer); err != nil {
 			return err
 		}
 		go vmServer.ServeCodec(jsonrpc.NewServerCodec(serverConn))
@@ -147,11 +146,11 @@ func main() {
 	}
 
 	daemoncmd.OnExportHook = launchVM
-	daemoncmd.OnStartHook = func (logger log.Logger, appOpts servertypes.AppOptions) error {
+	daemoncmd.OnStartHook = func(agdServer *vm.AgdServer, 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)
+		return launchVM(agdServer, logger, appOpts)
 	}
 
 	daemon.RunWithController(sendToNode)

package/cmd/libdaemon/main.go

@@ -37,22 +37,22 @@ 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)
+func ConnectVMClientCodec(ctx context.Context, nodePort int, sendFunc func(int, int, string)) (*vm.ClientCodec, vm.Sender) {
+	vmClientCodec = vm.NewClientCodec(ctx, sendFunc)
 	vmClient := rpc.NewClientWithCodec(vmClientCodec)
 
-	sendToNode := func(ctx context.Context, needReply bool, str string) (string, error) {
-		if str == "shutdown" {
+	var sendToNode vm.Sender = func(ctx context.Context, needReply bool, jsonRequest string) (jsonReply string, err error) {
+		if jsonRequest == "shutdown" {
 			return "", vmClientCodec.Close()
 		}
 
 		msg := vm.Message{
-			Port: nodePort,
+			Port:       nodePort,
 			NeedsReply: needReply,
-			Data: str,
+			Data:       jsonRequest,
 		}
 		var reply string
-		err := vmClient.Call(vm.ReceiveMessageMethod, msg, &reply)
+		err = vmClient.Call(vm.ReceiveMessageMethod, msg, &reply)
 		return reply, err
 	}
 
@@ -72,7 +72,7 @@ func RunAgCosmosDaemon(nodePort C.int, toNode C.sendFunc, cosmosArgs []*C.char)
 		panic(err)
 	}
 
-	var sendToNode daemoncmd.Sender
+	var sendToNode vm.Sender
 
 	sendFunc := func(port int, reply int, str string) {
 		C.invokeSendFunc(toNode, C.int(port), C.int(reply), C.CString(str))
@@ -83,7 +83,6 @@ func RunAgCosmosDaemon(nodePort C.int, toNode C.sendFunc, cosmosArgs []*C.char)
 		int(nodePort),
 		sendFunc,
 	)
-	agdServer = vm.NewAgdServer()
 
 	args := make([]string, len(cosmosArgs))
 	for i, s := range cosmosArgs {
@@ -96,7 +95,8 @@ func RunAgCosmosDaemon(nodePort C.int, toNode C.sendFunc, cosmosArgs []*C.char)
 		// 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(srv *vm.AgdServer, logger log.Logger, appOpts servertypes.AppOptions) error {
+			agdServer = srv
 			// We tried running start, which should never exit, so exit with non-zero
 			// code if we ever stop.
 			exitCode = 99
@@ -130,11 +130,11 @@ func SendToGo(port C.int, msg C.Body) C.Body {
 	// fmt.Fprintln(os.Stderr, "Send to Go", msgStr)
 	var respStr string
 	message := &vm.Message{
-		Port: int(port),
+		Port:       int(port),
 		NeedsReply: true,
-		Data: msgStr,
+		Data:       msgStr,
 	}
-	
+
 	err := agdServer.ReceiveMessage(message, &respStr)
 	if err == nil {
 		return C.CString(respStr)