@agoric/cosmos 0.34.2-upgrade-17-dev-e67cd91.0 → 0.34.2-upgrade-18-dev-d7c994b.0

package/app/app.go

@@ -655,6 +655,7 @@ func NewAgoricApp(
 		keys[vlocalchain.StoreKey],
 		app.BaseApp.MsgServiceRouter(),
 		app.BaseApp.GRPCQueryRouter(),
+		app.AccountKeeper,
 	)
 	app.vlocalchainPort = app.AgdServer.MustRegisterPortHandler(
 		"vlocalchain",

package/app/upgrade.go

@@ -1,7 +1,10 @@
 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"
@@ -72,6 +75,76 @@ func isFirstTimeUpgradeOfThisVersion(app *GaiaApp, ctx sdk.Context) bool {
 	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": [ {{.args}} ]
+	}`))
+
+	args, 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,
+		"args":       string(args),
+	})
+	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"
+	// Noupgrade for this version.
+    case "UNRELEASED_BASIC":
+        return ""
+    default:
+        return ""
+    }
+}
+
+func replaceElectorateCoreProposalStep(upgradeName string) (vm.CoreProposalStep, error) {
+    variant := getVariantFromUpgradeName(upgradeName)
+
+	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)
+
+	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) {
@@ -89,21 +162,35 @@ func unreleasedUpgradeHandler(app *GaiaApp, targetUpgrade string) func(sdk.Conte
 				return module.VersionMap{}, fmt.Errorf("cannot run %s as first upgrade", plan.Name)
 			}
 
+			replaceElectorateStep, err := replaceElectorateCoreProposalStep(targetUpgrade)
+			if err != nil {
+				return nil, err
+			}
+
+			priceFeedUpdate, err := replacePriceFeedsCoreProposal(targetUpgrade)
+			if err != nil {
+				return nil, err
+			}
+
 			// Each CoreProposalStep runs sequentially, and can be constructed from
 			// one or more modules executing in parallel within the step.
 			CoreProposalSteps = []vm.CoreProposalStep{
+				replaceElectorateStep,
+				priceFeedUpdate,
 				vm.CoreProposalStepForModules(
-					// Upgrade to new liveslots for repaired vow usage.
-					"@agoric/builders/scripts/vats/upgrade-orch-core.js",
+					"@agoric/builders/scripts/vats/add-auction.js",
 				),
 				vm.CoreProposalStepForModules(
-					// Upgrade to new liveslots and support vows.
-					"@agoric/builders/scripts/smart-wallet/build-wallet-factory2-upgrade.js",
+					"@agoric/builders/scripts/vats/upgradeVaults.js",
 				),
 				vm.CoreProposalStepForModules(
-					// Create vat-orchestration.
-					"@agoric/builders/scripts/vats/init-orchestration.js",
+					// 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",
+                ),
 			}
 		}
 

package/git-revision.txt

@@ -1 +1 @@
-e67cd91
+d7c994b

package/index.cjs

@@ -1,2 +1,2 @@
-/* global module require */
+/* eslint-env node */
 module.exports = require('bindings')('agcosmosdaemon.node');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/cosmos",
-  "version": "0.34.2-upgrade-17-dev-e67cd91.0+e67cd91",
+  "version": "0.34.2-upgrade-18-dev-d7c994b.0+d7c994b",
   "description": "Connect JS to the Cosmos blockchain SDK",
   "parsers": {
     "js": "mjs"
@@ -39,5 +39,5 @@
   "typeCoverage": {
     "atLeast": 0
   },
-  "gitHead": "e67cd918f33dafb1708bd4341f2a737b79fa574f"
+  "gitHead": "d7c994b8d33c0cd22b257f3e33b579588ab6c6d8"
 }

package/vm/action.go

@@ -86,7 +86,7 @@ func PopulateAction(ctx sdk.Context, action Action) Action {
 		var headerPtr *ActionHeader
 		if fieldType.Type == actionHeaderType {
 			headerPtr = field.Addr().Interface().(*ActionHeader)
-		} else if fieldType.Type == reflect.PtrTo(actionHeaderType) {
+		} else if fieldType.Type == reflect.PointerTo(actionHeaderType) {
 			if field.IsNil() {
 				headerPtr = &ActionHeader{}
 			} else {

package/x/vbank/vbank.go

@@ -144,11 +144,9 @@ func (ch portHandler) Receive(cctx context.Context, str string) (ret string, err
 		}
 		coin := keeper.GetBalance(ctx, addr, msg.Denom)
 		packet := coin.Amount.String()
+		bytes, err := json.Marshal(&packet)
 		if err == nil {
-			bytes, err := json.Marshal(&packet)
-			if err == nil {
-				ret = string(bytes)
-			}
+			ret = string(bytes)
 		}
 
 	case "VBANK_GRAB":
@@ -216,9 +214,6 @@ func (ch portHandler) Receive(cctx context.Context, str string) (ret string, err
 		if err := keeper.StoreRewardCoins(ctx, coins); err != nil {
 			return "", fmt.Errorf("cannot store reward %s coins: %s", coins.Sort().String(), err)
 		}
-		if err != nil {
-			return "", err
-		}
 		state := keeper.GetState(ctx)
 		state.RewardPool = state.RewardPool.Add(coins...)
 		keeper.SetState(ctx, state)

package/x/vlocalchain/keeper/keeper.go

@@ -28,6 +28,7 @@ type Keeper struct {
 	cdc         codec.Codec
 	msgRouter   types.MsgRouter
 	queryRouter types.GRPCQueryRouter
+	acctKeeper  types.AccountKeeper
 }
 
 // NewKeeper creates a new dIBC Keeper instance
@@ -36,12 +37,14 @@ func NewKeeper(
 	key storetypes.StoreKey,
 	msgRouter types.MsgRouter,
 	queryRouter types.GRPCQueryRouter,
+	acctKeeper types.AccountKeeper,
 ) Keeper {
 	return Keeper{
 		key:         key,
 		cdc:         cdc,
 		msgRouter:   msgRouter,
 		queryRouter: queryRouter,
+		acctKeeper:  acctKeeper,
 	}
 }
 
@@ -266,14 +269,27 @@ func (k Keeper) AllocateAddress(cctx context.Context) sdk.AccAddress {
 	localchainModuleAcc := sdkaddress.Module(types.ModuleName, []byte("localchain"))
 	header := ctx.BlockHeader()
 
-	// Increment our sequence number.
-	seq := store.Get(types.KeyLastSequence)
-	seq = types.NextSequence(seq)
-	store.Set(types.KeyLastSequence, seq)
+	// Loop until we find an unused address.
+	for {
+		// Increment our sequence number.
+		seq := store.Get(types.KeyLastSequence)
+		seq = types.NextSequence(seq)
+		store.Set(types.KeyLastSequence, seq)
 
-	buf := seq
-	buf = append(buf, header.AppHash...)
-	buf = append(buf, header.DataHash...)
+		buf := seq
+		buf = append(buf, header.AppHash...)
+		buf = append(buf, header.DataHash...)
 
-	return sdkaddress.Derive(localchainModuleAcc, buf)
+		addr := sdkaddress.Derive(localchainModuleAcc, buf)
+		if k.acctKeeper.HasAccount(ctx, addr) {
+			continue
+		}
+
+		// We found an unused address, so create an account for it.
+		acct := k.acctKeeper.NewAccountWithAddress(ctx, addr)
+		k.acctKeeper.SetAccount(ctx, acct)
+
+		// All good, return the address.
+		return addr
+	}
 }

package/x/vlocalchain/keeper/keeper_test.go

@@ -10,7 +10,6 @@ import (
 	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
 )
 
-
 func TestKeeper_ParseRequestTypeURL(t *testing.T) {
 	testCases := []struct {
 		name        string
@@ -46,7 +45,7 @@ func TestKeeper_DeserializeTxMessages(t *testing.T) {
 
 	banktypes.RegisterInterfaces(encodingConfig.InterfaceRegistry)
 
-	keeper := NewKeeper(cdc, nil, nil, nil)
+	keeper := NewKeeper(cdc, nil, nil, nil, nil)
 
 	expectedMsgSend := []sdk.Msg{
 		&banktypes.MsgSend{
@@ -63,22 +62,22 @@ func TestKeeper_DeserializeTxMessages(t *testing.T) {
 		wantErr  bool
 	}{
 		{
-			name: "camelCase keys",
-			json: `{"messages":[{"@type":"/cosmos.bank.v1beta1.MsgSend","fromAddress":"cosmos1abc","toAddress":"cosmos1xyz","amount":[{"denom":"stake","amount":"100"}]}]}`,
+			name:     "camelCase keys",
+			json:     `{"messages":[{"@type":"/cosmos.bank.v1beta1.MsgSend","fromAddress":"cosmos1abc","toAddress":"cosmos1xyz","amount":[{"denom":"stake","amount":"100"}]}]}`,
 			expected: expectedMsgSend,
-			wantErr: false,
+			wantErr:  false,
 		},
 		{
-			name: "snake_case keys",
-			json: `{"messages":[{"@type":"/cosmos.bank.v1beta1.MsgSend","from_address":"cosmos1abc","to_address":"cosmos1xyz","amount":[{"denom":"stake","amount":"100"}]}]}`,
+			name:     "snake_case keys",
+			json:     `{"messages":[{"@type":"/cosmos.bank.v1beta1.MsgSend","from_address":"cosmos1abc","to_address":"cosmos1xyz","amount":[{"denom":"stake","amount":"100"}]}]}`,
 			expected: expectedMsgSend,
-			wantErr: false,
+			wantErr:  false,
 		},
 		{
-			name: "misspelled key",
-			json: `{"messages":[{"@type":"/cosmos.bank.v1beta1.MsgSend","from_addresss":"cosmos1abc","to_address":"cosmos1xyz","amount":[{"denom":"stake","amount":"100"}]}]}`,
+			name:     "misspelled key",
+			json:     `{"messages":[{"@type":"/cosmos.bank.v1beta1.MsgSend","from_addresss":"cosmos1abc","to_address":"cosmos1xyz","amount":[{"denom":"stake","amount":"100"}]}]}`,
 			expected: expectedMsgSend,
-			wantErr: true,
+			wantErr:  true,
 		},
 	}
 

package/x/vlocalchain/types/expected_keepers.go

@@ -0,0 +1,12 @@
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+)
+
+type AccountKeeper interface {
+	NewAccountWithAddress(ctx sdk.Context, addr sdk.AccAddress) authtypes.AccountI
+	HasAccount(ctx sdk.Context, addr sdk.AccAddress) bool
+	SetAccount(ctx sdk.Context, acc authtypes.AccountI)
+}

package/x/vlocalchain/vlocalchain_test.go

@@ -16,6 +16,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/store"
 	storetypes "github.com/cosmos/cosmos-sdk/store/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
 	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 	transfertypes "github.com/cosmos/ibc-go/v6/modules/apps/transfer/types"
@@ -36,6 +37,25 @@ const (
 	msgAllocateAddress = `{"type":"VLOCALCHAIN_ALLOCATE_ADDRESS"}`
 )
 
+type mockAccounts struct {
+	existing map[string]bool
+}
+
+var _ types.AccountKeeper = (*mockAccounts)(nil)
+
+func (a *mockAccounts) NewAccountWithAddress(ctx sdk.Context, addr sdk.AccAddress) authtypes.AccountI {
+	return authtypes.NewBaseAccountWithAddress(addr)
+}
+
+func (a *mockAccounts) HasAccount(ctx sdk.Context, addr sdk.AccAddress) bool {
+	existing := a.existing[addr.String()]
+	return existing
+}
+
+func (a *mockAccounts) SetAccount(ctx sdk.Context, acc authtypes.AccountI) {
+	a.existing[acc.GetAddress().String()] = true
+}
+
 type mockBank struct {
 	banktypes.UnimplementedQueryServer
 	banktypes.UnimplementedMsgServer
@@ -108,7 +128,7 @@ func (s *mockStaking) UnbondingDelegation(cctx context.Context, req *stakingtype
 }
 
 // makeTestKit creates a minimal Keeper and Context for use in testing.
-func makeTestKit(bank *mockBank, transfer *mockTransfer, staking *mockStaking) (vm.PortHandler, context.Context) {
+func makeTestKit(bank *mockBank, transfer *mockTransfer, staking *mockStaking, accts *mockAccounts) (vm.PortHandler, context.Context) {
 	encodingConfig := params.MakeEncodingConfig()
 	cdc := encodingConfig.Marshaler
 
@@ -127,9 +147,8 @@ func makeTestKit(bank *mockBank, transfer *mockTransfer, staking *mockStaking) (
 	stakingtypes.RegisterMsgServer(txRouter, staking)
 	stakingtypes.RegisterQueryServer(queryRouter, staking)
 
-
 	// create a new Keeper
-	keeper := vlocalchain.NewKeeper(cdc, vlocalchainStoreKey, txRouter, queryRouter)
+	keeper := vlocalchain.NewKeeper(cdc, vlocalchainStoreKey, txRouter, queryRouter, accts)
 
 	db := dbm.NewMemDB()
 	ms := store.NewCommitMultiStore(db)
@@ -153,13 +172,15 @@ func TestAllocateAddress(t *testing.T) {
 	bank := &mockBank{}
 	transfer := &mockTransfer{}
 	staking := &mockStaking{}
-	handler, cctx := makeTestKit(bank, transfer, staking)
+	acct := &mockAccounts{existing: map[string]bool{
+		firstAddr: true,
+		"cosmos1c5hplwyxk5jr2dsygjqepzfqvfukwduq9c4660aah76krf99m6gs0k7hvl": true,
+	}}
+	handler, cctx := makeTestKit(bank, transfer, staking, acct)
 
 	addrs := map[string]bool{
-		firstAddr: false,
 		"cosmos1yj40fakym8kf4wvgz9tky7k9f3v9msm3t7frscrmkjsdkxkpsfkqgeczkg": false,
 		"cosmos1s76vryj7m8k8nm9le65a4plhf5rym5sumtt2n0vwnk5l6k4cwuhsj56ujj": false,
-		"cosmos1c5hplwyxk5jr2dsygjqepzfqvfukwduq9c4660aah76krf99m6gs0k7hvl": false,
 		"cosmos1ys3a7mtna3cad0wxcs4ddukn37stexjdvns8jfdn4uerlr95y4xqnrypf6": false,
 	}
 	numToTest := len(addrs)
@@ -185,6 +206,9 @@ func TestAllocateAddress(t *testing.T) {
 			t.Fatalf("unexpected duplicate address[%d]: %v", i, addr)
 		}
 		addrs[addr] = true
+		if !acct.existing[addr] {
+			t.Fatalf("expected address[%d]: %v to be added to accounts", i, addr)
+		}
 	}
 }
 
@@ -197,7 +221,8 @@ func TestQuery(t *testing.T) {
 	}}
 	transfer := &mockTransfer{}
 	staking := &mockStaking{}
-	handler, cctx := makeTestKit(bank, transfer, staking)
+	accts := &mockAccounts{existing: map[string]bool{}}
+	handler, cctx := makeTestKit(bank, transfer, staking, accts)
 
 	// get balances
 	testCases := []struct {
@@ -338,7 +363,8 @@ func TestExecuteTx(t *testing.T) {
 	}}
 	transfer := &mockTransfer{}
 	staking := &mockStaking{}
-	handler, cctx := makeTestKit(bank, transfer, staking)
+	accts := &mockAccounts{existing: map[string]bool{}}
+	handler, cctx := makeTestKit(bank, transfer, staking, accts)
 
 	// create a new message
 	msg := `{"type":"VLOCALCHAIN_ALLOCATE_ADDRESS"}`
@@ -426,7 +452,7 @@ func TestExecuteTx(t *testing.T) {
 		if len(resp) != 1 {
 			t.Fatalf("expected 1 response, got %d", len(resp))
 		}
-		
+
 		if _, ok := resp[0]["completionTime"]; !ok {
 			t.Error("expected 'completionTime' field in response")
 		}