@agoric/cosmos 0.35.0-u12.0 → 0.35.0-upgrade-14-dev-1eb5b91.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/cosmos",
-  "version": "0.35.0-u12.0",
+  "version": "0.35.0-upgrade-14-dev-1eb5b91.0+1eb5b91",
   "description": "Connect JS to the Cosmos blockchain SDK",
   "parsers": {
     "js": "mjs"
@@ -35,5 +35,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "ee5a5fdad9187a6b1b7b26b772b6564c0db3062e"
+  "gitHead": "1eb5b91cd8b085f1e62b1eb84fdebf72e4a3fbd9"
 }

package/vm/action.go

@@ -0,0 +1,130 @@
+package vm
+
+import (
+	"reflect"
+	"strconv"
+	"time"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+var (
+	zeroTime                = time.Time{}
+	actionHeaderType        = reflect.TypeOf(ActionHeader{})
+	_                Action = &ActionHeader{}
+)
+
+// Jsonable is a value, j, that can be passed through json.Marshal(j).
+type Jsonable interface{}
+
+type Action interface {
+	GetActionHeader() ActionHeader
+}
+
+// ActionPusher enqueues data for later consumption by the controller.
+type ActionPusher func(ctx sdk.Context, action Action) error
+
+// ActionHeader should be embedded in all actions.  It is populated by PopulateAction.
+type ActionHeader struct {
+	// Type defaults to the `actionType:"..."` tag of the embedder's ActionHeader field.
+	Type string `json:"type"`
+	// BlockHeight defaults to sdk.Context.BlockHeight().
+	BlockHeight int64 `json:"blockHeight,omitempty"`
+	// BlockTime defaults to sdk.Context.BlockTime().Unix().
+	BlockTime int64 `json:"blockTime,omitempty"`
+}
+
+func (ah ActionHeader) GetActionHeader() ActionHeader {
+	return ah
+}
+
+// SetActionHeaderFromContext provides defaults to an ActionHeader.
+func SetActionHeaderFromContext(ctx sdk.Context, actionType string, ah *ActionHeader) {
+	// Default the action type.
+	if len(ah.Type) == 0 {
+		ah.Type = actionType
+	}
+
+	// Default the block height.
+	if ah.BlockHeight == 0 {
+		ah.BlockHeight = ctx.BlockHeight()
+	}
+
+	if ah.BlockTime == 0 {
+		// Only default to a non-zero block time.
+		if blockTime := ctx.BlockTime(); blockTime != zeroTime {
+			ah.BlockTime = blockTime.Unix()
+		}
+	}
+}
+
+// PopulateAction interprets `default:"..."` tags and specially handles an
+// embedded ActionHeader struct.
+func PopulateAction(ctx sdk.Context, action Action) Action {
+	oldRv := reflect.Indirect(reflect.ValueOf(action))
+	if oldRv.Kind() != reflect.Struct {
+		return action
+	}
+
+	// Shallow copy to a new value.
+	rp := reflect.New(oldRv.Type())
+	rv := reflect.Indirect(rp)
+	for i := 0; i < rv.NumField(); i++ {
+		oldField := oldRv.Field(i)
+		field := rv.Field(i)
+		fieldType := rv.Type().Field(i)
+		if !field.CanSet() {
+			continue
+		}
+
+		// Copy from original.
+		field.Set(oldField)
+
+		// Populate any ActionHeader struct.
+		var ahp *ActionHeader
+		if fieldType.Type == actionHeaderType {
+			ahp = field.Addr().Interface().(*ActionHeader)
+		} else if fieldType.Type == reflect.PtrTo(actionHeaderType) {
+			if field.IsNil() {
+				ahp = &ActionHeader{}
+			} else {
+				ahp = field.Interface().(*ActionHeader)
+			}
+		}
+		if ahp != nil {
+			actionTypeTag, _ := fieldType.Tag.Lookup("actionType")
+			ah := *ahp
+			SetActionHeaderFromContext(ctx, actionTypeTag, &ah)
+			if field.Kind() == reflect.Ptr {
+				field.Set(reflect.ValueOf(&ah))
+			} else {
+				field.Set(reflect.ValueOf(ah))
+			}
+			continue
+		}
+
+		// Still zero value, try default struct field tag.
+		defaultTag, _ := fieldType.Tag.Lookup("default")
+		if !field.IsZero() || len(defaultTag) == 0 {
+			continue
+		}
+
+		switch field.Kind() {
+		case reflect.String:
+			field.SetString(defaultTag)
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			if val, err := strconv.ParseInt(defaultTag, 0, 64); err == nil {
+				field.SetInt(val)
+			}
+		case reflect.Bool:
+			if val, err := strconv.ParseBool(defaultTag); err == nil {
+				field.SetBool(val)
+			}
+		case reflect.Float32, reflect.Float64:
+			if val, err := strconv.ParseFloat(defaultTag, 64); err == nil {
+				field.SetFloat(val)
+			}
+		}
+	}
+	return rv.Interface().(Action)
+}

package/vm/action_test.go

@@ -0,0 +1,129 @@
+package vm_test
+
+import (
+	"encoding/json"
+	"testing"
+	"time"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+var (
+	_ vm.Action = &Trivial{}
+	_ vm.Action = &Defaults{}
+	_ vm.Action = &dataAction{}
+)
+
+type Trivial struct {
+	vm.ActionHeader
+	Abc int
+	def string
+}
+
+type Defaults struct {
+	String string  `default:"abc"`
+	Int    int     `default:"123"`
+	Float  float64 `default:"4.56"`
+	Bool   bool    `default:"true"`
+	Any    interface{}
+}
+
+func (d Defaults) GetActionHeader() vm.ActionHeader {
+	return vm.ActionHeader{}
+}
+
+type dataAction struct {
+	*vm.ActionHeader `actionType:"DATA_ACTION"`
+	Data             []byte
+}
+
+func TestActionContext(t *testing.T) {
+	emptyCtx := sdk.Context{}
+
+	testCases := []struct {
+		name        string
+		ctx         sdk.Context
+		in          vm.Action
+		expectedOut interface{}
+	}{
+		{"nil", emptyCtx, nil, nil},
+		{"no context", emptyCtx,
+			&Trivial{Abc: 123, def: "zot"},
+			&Trivial{Abc: 123, def: "zot"},
+		},
+		{"block height",
+			emptyCtx.WithBlockHeight(998),
+			&Trivial{Abc: 123, def: "zot"},
+			&Trivial{ActionHeader: vm.ActionHeader{BlockHeight: 998}, Abc: 123, def: "zot"},
+		},
+		{"block time",
+			emptyCtx.WithBlockTime(time.UnixMicro(1_000_000)),
+			&Trivial{Abc: 123, def: "zot"},
+			&Trivial{Abc: 123, def: "zot", ActionHeader: vm.ActionHeader{BlockTime: 1}},
+		},
+		{"default tags",
+			emptyCtx,
+			&Defaults{},
+			&Defaults{"abc", 123, 4.56, true, nil},
+		},
+		{"data action defaults",
+			emptyCtx.WithBlockHeight(998).WithBlockTime(time.UnixMicro(1_000_000)),
+			&dataAction{Data: []byte("hello")},
+			&dataAction{Data: []byte("hello"),
+				ActionHeader: &vm.ActionHeader{Type: "DATA_ACTION", BlockHeight: 998, BlockTime: 1}},
+		},
+		{"data action override Type",
+			emptyCtx.WithBlockHeight(998).WithBlockTime(time.UnixMicro(1_000_000)),
+			&dataAction{Data: []byte("hello2"),
+				ActionHeader: &vm.ActionHeader{Type: "DATA_ACTION2"}},
+			&dataAction{Data: []byte("hello2"),
+				ActionHeader: &vm.ActionHeader{Type: "DATA_ACTION2", BlockHeight: 998, BlockTime: 1}},
+		},
+		{"data action override BlockHeight",
+			emptyCtx.WithBlockHeight(998).WithBlockTime(time.UnixMicro(1_000_000)),
+			&dataAction{Data: []byte("hello2"),
+				ActionHeader: &vm.ActionHeader{BlockHeight: 999}},
+			&dataAction{Data: []byte("hello2"),
+				ActionHeader: &vm.ActionHeader{Type: "DATA_ACTION", BlockHeight: 999, BlockTime: 1}},
+		},
+		{"data action override BlockTime",
+			emptyCtx.WithBlockHeight(998).WithBlockTime(time.UnixMicro(1_000_000)),
+			&dataAction{Data: []byte("hello2"),
+				ActionHeader: &vm.ActionHeader{BlockTime: 2}},
+			&dataAction{Data: []byte("hello2"),
+				ActionHeader: &vm.ActionHeader{Type: "DATA_ACTION", BlockHeight: 998, BlockTime: 2}},
+		},
+		{"data action override all defaults",
+			emptyCtx.WithBlockHeight(998).WithBlockTime(time.UnixMicro(1_000_000)),
+			&dataAction{Data: []byte("hello2"),
+				ActionHeader: &vm.ActionHeader{Type: "DATA_ACTION2", BlockHeight: 999, BlockTime: 2}},
+			&dataAction{Data: []byte("hello2"),
+				ActionHeader: &vm.ActionHeader{Type: "DATA_ACTION2", BlockHeight: 999, BlockTime: 2}},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			jstr := func(in interface{}) string {
+				bz, err := json.Marshal(in)
+				if err != nil {
+					t.Fatal(err)
+				}
+				return string(bz)
+			}
+			jsonIn := jstr(tc.in)
+			out := vm.PopulateAction(tc.ctx, tc.in)
+			jsonIn2 := jstr(tc.in)
+			if jsonIn != jsonIn2 {
+				t.Errorf("unexpected mutated input: %s to %s", jsonIn, jsonIn2)
+			}
+			jsonOut := jstr(out)
+			jsonExpectedOut := jstr(tc.expectedOut)
+			if jsonOut != jsonExpectedOut {
+				t.Errorf("expected %s, got %s", jsonExpectedOut, jsonOut)
+			}
+		})
+	}
+}

package/vm/controller.go

@@ -25,12 +25,6 @@ type ControllerAdmissionMsg interface {
 	IsHighPriority(sdk.Context, interface{}) (bool, error)
 }
 
-// Jsonable is a value, j, that can be passed through json.Marshal(j).
-type Jsonable interface{}
-
-// ActionPusher enqueues data for later consumption by the controller.
-type ActionPusher func(ctx sdk.Context, action Jsonable) error
-
 var controllerContext ControllerContext
 
 type PortHandler interface {

package/vm/core_proposals.go

@@ -0,0 +1,31 @@
+package vm
+
+// CoreProposalStep is a set of core proposal configs which are executed
+// concurrently
+type CoreProposalStep []Jsonable
+
+// CoreProposals is one possible shape for core proposals expressed as a series
+// of sequential steps
+// see SequentialCoreProposals in packages/deploy-script-support/src/extract-proposal.js
+type CoreProposals struct {
+	Steps []CoreProposalStep `json:"steps"`
+}
+
+// CoreProposalStepForModules generates a single core proposal step from
+// the given modules, which will be executed concurrently during that step
+func CoreProposalStepForModules(modules ...string) CoreProposalStep {
+	step := make([]Jsonable, len(modules))
+	for i := range modules {
+		step[i] = modules[i]
+	}
+	return step
+}
+
+// CoreProposalsFromSteps returns a CoreProposals from the given steps
+func CoreProposalsFromSteps(steps ...CoreProposalStep) *CoreProposals {
+	if steps == nil {
+		// Deal with https://github.com/golang/go/issues/37711
+		return &CoreProposals{Steps: []CoreProposalStep{}}
+	}
+	return &CoreProposals{Steps: steps}
+}

package/x/lien/keeper/account.go

@@ -16,16 +16,16 @@ import (
 // In addition to the methods declared in authtypes.AccountI, additional
 // expectations are enforced dynamically through casting and reflection:
 //
-//	- non-module accounts are expected to obey the GenesisAccount interface,
-//	i.e. to have a Validate() method;
+//   - non-module accounts are expected to obey the GenesisAccount interface,
+//     i.e. to have a Validate() method;
 //
-//	- UnpackInterfacesMessage is needed for unpacking accounts embedded
-//	in an Any message;
+//   - UnpackInterfacesMessage is needed for unpacking accounts embedded
+//     in an Any message;
 //
-//	- MarshalYAML() is used for String rendering;
+//   - MarshalYAML() is used for String rendering;
 //
-//	- protobuf Messages are expected to implement a number of "XXX"-prefixed
-//	methods not visible in the Message interface.
+//   - protobuf Messages are expected to implement a number of "XXX"-prefixed
+//     methods not visible in the Message interface.
 //
 // Declaring the expected methods here allows them to implicitly fall through
 // to an embedded omniAccount.
@@ -116,7 +116,7 @@ func (uva unlockedVestingAccount) GetOriginalVesting() sdk.Coins {
 	return sdk.NewCoins()
 }
 
-//GetDelegatedFree implements the vestexported.VestingAccount interface.
+// GetDelegatedFree implements the vestexported.VestingAccount interface.
 func (uva unlockedVestingAccount) GetDelegatedFree() sdk.Coins {
 	return uva.lien.Delegated
 }
@@ -172,6 +172,11 @@ func (fca fakeClawbackAccount) PostReward(ctx sdk.Context, reward sdk.Coins, act
 	return nil
 }
 
+// ReturnGrants implements the vestexported.ClawbackVestingAccountI interface.
+func (fca fakeClawbackAccount) ReturnGrants(ctx sdk.Context, action vestexported.ReturnGrantAction) error {
+	return action.TakeGrants(ctx, fca.omniGrantAccount) // XXX or just fail here
+}
+
 // LienAccount wraps an omniClawbackAccount to implement lien encumbrance.
 // The LockedCoins() method is the maximum of the coins locked for
 // liens, and the coins locked in the underlying VestingAccount.

package/x/lien/keeper/keeper_test.go

@@ -112,7 +112,7 @@ func makeTestKit() testKit {
 	sk := stakingkeeper.NewKeeper(cdc, stakingStoreKey, wak, bk, stakingSpace)
 
 	// lien keeper
-	pushAction := func(sdk.Context, vm.Jsonable) error {
+	pushAction := func(sdk.Context, vm.Action) error {
 		return nil
 	}
 	keeper := NewKeeper(cdc, lienStoreKey, wak, bk, sk, pushAction)

package/x/swingset/abci.go

@@ -2,6 +2,7 @@ package swingset
 
 import (
 	// "os"
+	"context"
 	"fmt"
 	"time"
 
@@ -9,38 +10,34 @@ 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"`
-	BlockHeight int64        `json:"blockHeight"`
-	BlockTime   int64        `json:"blockTime"`
-	ChainID     string       `json:"chainID"`
-	Params      types.Params `json:"params"`
+	vm.ActionHeader `actionType:"BEGIN_BLOCK"`
+	ChainID         string       `json:"chainID"`
+	Params          types.Params `json:"params"`
 }
 
 type endBlockAction struct {
-	Type        string `json:"type"`
-	BlockHeight int64  `json:"blockHeight"`
-	BlockTime   int64  `json:"blockTime"`
+	vm.ActionHeader `actionType:"END_BLOCK"`
 }
 
 type commitBlockAction struct {
-	Type        string `json:"type"`
-	BlockHeight int64  `json:"blockHeight"`
-	BlockTime   int64  `json:"blockTime"`
+	vm.ActionHeader `actionType:"COMMIT_BLOCK"`
+}
+
+type afterCommitBlockAction struct {
+	vm.ActionHeader `actionType:"AFTER_COMMIT_BLOCK"`
 }
 
 func BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock, keeper Keeper) error {
 	defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), telemetry.MetricKeyBeginBlocker)
 
 	action := &beginBlockAction{
-		Type:        "BEGIN_BLOCK",
-		BlockHeight: ctx.BlockHeight(),
-		BlockTime:   ctx.BlockTime().Unix(),
-		ChainID:     ctx.ChainID(),
-		Params:      keeper.GetParams(ctx),
+		ChainID: ctx.ChainID(),
+		Params:  keeper.GetParams(ctx),
 	}
 	_, err := keeper.BlockingSend(ctx, action)
 	// fmt.Fprintf(os.Stderr, "BEGIN_BLOCK Returned from SwingSet: %s, %v\n", out, err)
@@ -59,11 +56,7 @@ var endBlockTime int64
 func EndBlock(ctx sdk.Context, req abci.RequestEndBlock, keeper Keeper) ([]abci.ValidatorUpdate, error) {
 	defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), telemetry.MetricKeyEndBlocker)
 
-	action := &endBlockAction{
-		Type:        "END_BLOCK",
-		BlockHeight: ctx.BlockHeight(),
-		BlockTime:   ctx.BlockTime().Unix(),
-	}
+	action := &endBlockAction{}
 	_, err := keeper.BlockingSend(ctx, action)
 
 	// fmt.Fprintf(os.Stderr, "END_BLOCK Returned from SwingSet: %s, %v\n", out, err)
@@ -80,15 +73,18 @@ func EndBlock(ctx sdk.Context, req abci.RequestEndBlock, keeper Keeper) ([]abci.
 	return []abci.ValidatorUpdate{}, nil
 }
 
+func getEndBlockContext() sdk.Context {
+	return sdk.Context{}.
+		WithContext(context.Background()).
+		WithBlockHeight(endBlockHeight).
+		WithBlockTime(time.Unix(endBlockTime, 0))
+}
+
 func CommitBlock(keeper Keeper) error {
 	defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), "commit_blocker")
 
-	action := &commitBlockAction{
-		Type:        "COMMIT_BLOCK",
-		BlockHeight: endBlockHeight,
-		BlockTime:   endBlockTime,
-	}
-	_, err := keeper.BlockingSend(sdk.Context{}, action)
+	action := &commitBlockAction{}
+	_, err := keeper.BlockingSend(getEndBlockContext(), action)
 
 	// fmt.Fprintf(os.Stderr, "COMMIT_BLOCK Returned from SwingSet: %s, %v\n", out, err)
 	if err != nil {
@@ -102,12 +98,8 @@ func CommitBlock(keeper Keeper) error {
 func AfterCommitBlock(keeper Keeper) error {
 	// defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), "commit_blocker")
 
-	action := &commitBlockAction{
-		Type:        "AFTER_COMMIT_BLOCK",
-		BlockHeight: endBlockHeight,
-		BlockTime:   endBlockTime,
-	}
-	_, err := keeper.BlockingSend(sdk.Context{}, action)
+	action := &afterCommitBlockAction{}
+	_, err := keeper.BlockingSend(getEndBlockContext(), action)
 
 	// fmt.Fprintf(os.Stderr, "AFTER_COMMIT_BLOCK Returned from SwingSet: %s, %v\n", out, err)
 	if err != nil {

package/x/swingset/keeper/keeper.go

@@ -37,6 +37,12 @@ const (
 	StoragePathSwingStore          = "swingStore"
 )
 
+const (
+	// WalletStoragePathSegment matches the value of WALLET_STORAGE_PATH_SEGMENT
+	// packages/vats/src/core/startWalletFactory.js
+	WalletStoragePathSegment = "wallet"
+)
+
 const (
 	stateKey            = "state"
 	swingStoreKeyPrefix = "swingStore."
@@ -104,6 +110,16 @@ func NewKeeper(
 	}
 }
 
+func populateAction(ctx sdk.Context, action vm.Action) (vm.Action, error) {
+	action = vm.PopulateAction(ctx, action)
+	ah := action.GetActionHeader()
+	if len(ah.Type) == 0 {
+		return nil, fmt.Errorf("action %q cannot have an empty ActionHeader.Type", action)
+	}
+
+	return action, nil
+}
+
 // pushAction appends an action to the controller's specified inbound queue.
 // The queue is kept in the kvstore so that changes are properly reverted if the
 // kvstore is rolled back.  By the time the block manager runs, it can commit
@@ -112,7 +128,11 @@ func NewKeeper(
 //
 // The inbound queue's format is documented by `makeChainQueue` in
 // `packages/cosmic-swingset/src/helpers/make-queue.js`.
-func (k Keeper) pushAction(ctx sdk.Context, inboundQueuePath string, action vm.Jsonable) error {
+func (k Keeper) pushAction(ctx sdk.Context, inboundQueuePath string, action vm.Action) error {
+	action, err := populateAction(ctx, action)
+	if err != nil {
+		return err
+	}
 	txHash, txHashOk := ctx.Context().Value(baseapp.TxHashContextKey).(string)
 	if !txHashOk {
 		txHash = "unknown"
@@ -137,12 +157,12 @@ func (k Keeper) pushAction(ctx sdk.Context, inboundQueuePath string, action vm.J
 }
 
 // PushAction appends an action to the controller's actionQueue.
-func (k Keeper) PushAction(ctx sdk.Context, action vm.Jsonable) error {
+func (k Keeper) PushAction(ctx sdk.Context, action vm.Action) error {
 	return k.pushAction(ctx, StoragePathActionQueue, action)
 }
 
 // PushAction appends an action to the controller's highPriorityQueue.
-func (k Keeper) PushHighPriorityAction(ctx sdk.Context, action vm.Jsonable) error {
+func (k Keeper) PushHighPriorityAction(ctx sdk.Context, action vm.Action) error {
 	return k.pushAction(ctx, StoragePathHighPriorityQueue, action)
 }
 
@@ -151,6 +171,20 @@ func (k Keeper) IsHighPriorityAddress(ctx sdk.Context, addr sdk.AccAddress) (boo
 	return k.vstorageKeeper.HasEntry(ctx, path), nil
 }
 
+// GetSmartWalletState returns the provision state of the smart wallet for the account address
+func (k Keeper) GetSmartWalletState(ctx sdk.Context, addr sdk.AccAddress) types.SmartWalletState {
+	// walletStoragePath is path of `walletStorageNode` constructed in
+	// `provideSmartWallet` from packages/smart-wallet/src/walletFactory.js
+	walletStoragePath := StoragePathCustom + "." + WalletStoragePathSegment + "." + addr.String()
+
+	// TODO: implement a pending provision state
+	if k.vstorageKeeper.HasEntry(ctx, walletStoragePath) {
+		return types.SmartWalletStateProvisioned
+	}
+
+	return types.SmartWalletStateNone
+}
+
 func (k Keeper) InboundQueueLength(ctx sdk.Context) (int32, error) {
 	size := sdk.NewInt(0)
 
@@ -214,7 +248,11 @@ func (k Keeper) UpdateQueueAllowed(ctx sdk.Context) error {
 // until the response.  It is orthogonal to PushAction, and should only be used
 // by SwingSet to perform block lifecycle events (BEGIN_BLOCK, END_BLOCK,
 // COMMIT_BLOCK).
-func (k Keeper) BlockingSend(ctx sdk.Context, action vm.Jsonable) (string, error) {
+func (k Keeper) BlockingSend(ctx sdk.Context, action vm.Action) (string, error) {
+	action, err := populateAction(ctx, action)
+	if err != nil {
+		return "", err
+	}
 	bz, err := json.Marshal(action)
 	if err != nil {
 		return "", err
@@ -315,6 +353,25 @@ func (k Keeper) ChargeBeans(ctx sdk.Context, addr sdk.AccAddress, beans sdk.Uint
 	return nil
 }
 
+// ChargeForSmartWallet charges the fee for provisioning a smart wallet.
+func (k Keeper) ChargeForSmartWallet(ctx sdk.Context, addr sdk.AccAddress) error {
+	beansPerUnit := k.GetBeansPerUnit(ctx)
+	beans := beansPerUnit[types.BeansPerSmartWalletProvision]
+	err := k.ChargeBeans(ctx, addr, beans)
+	if err != nil {
+		return err
+	}
+
+	// TODO: mark that a smart wallet provision is pending. However in that case,
+	// auto-provisioning should still be performed (but without fees being charged),
+	// until the controller actually provisions the smart wallet (the operation may
+	// transiently fail, requiring retries until success).
+	// However the provisioning code is not currently idempotent, and has side
+	// effects when the smart wallet is already provisioned.
+
+	return nil
+}
+
 // makeFeeMenu returns a map from power flag to its fee.  In the case of duplicates, the
 // first one wins.
 func makeFeeMenu(powerFlagFees []types.PowerFlagFee) map[string]sdk.Coins {

package/x/swingset/keeper/migrations.go

@@ -1,7 +1,7 @@
 package keeper
 
 import (
-	v32 "github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/legacy/v32"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
@@ -17,8 +17,13 @@ func NewMigrator(keeper Keeper) Migrator {
 
 // Migrate1to2 migrates from version 1 to 2.
 func (m Migrator) Migrate1to2(ctx sdk.Context) error {
+	return m.MigrateParams(ctx)
+}
+
+// MigrateParams migrates params by setting new params to their default value
+func (m Migrator) MigrateParams(ctx sdk.Context) error {
 	params := m.keeper.GetParams(ctx)
-	newParams, err := v32.UpdateParams(params)
+	newParams, err := types.UpdateParams(params)
 	if err != nil {
 		return err
 	}