@agoric/cosmos 0.35.0-mainnet1B-dev-cfa7cb2.0 → 0.35.0-mainnet1B-dev-b0c1f78.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/cosmos",
-  "version": "0.35.0-mainnet1B-dev-cfa7cb2.0+cfa7cb2",
+  "version": "0.35.0-mainnet1B-dev-b0c1f78.0+b0c1f78",
   "description": "Connect JS to the Cosmos blockchain SDK",
   "parsers": {
     "js": "mjs"
@@ -35,5 +35,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "cfa7cb2bf1aa80bc60741a0eb5ba884995e8ee4c"
+  "gitHead": "b0c1f788a06e8593426319de068acd64a390d349"
 }

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/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."
@@ -151,6 +157,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)
 
@@ -315,6 +335,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
 	}

package/x/swingset/keeper/msg_server.go

@@ -80,6 +80,11 @@ type walletAction struct {
 func (keeper msgServer) WalletAction(goCtx context.Context, msg *types.MsgWalletAction) (*types.MsgWalletActionResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
+	err := keeper.provisionIfNeeded(ctx, msg.Owner)
+	if err != nil {
+		return nil, err
+	}
+
 	action := &walletAction{
 		Type:        "WALLET_ACTION",
 		Owner:       msg.Owner.String(),
@@ -89,7 +94,7 @@ func (keeper msgServer) WalletAction(goCtx context.Context, msg *types.MsgWallet
 	}
 	// fmt.Fprintf(os.Stderr, "Context is %+v\n", ctx)
 
-	err := keeper.routeAction(ctx, msg, action)
+	err = keeper.routeAction(ctx, msg, action)
 	// fmt.Fprintln(os.Stderr, "Returned from SwingSet", out, err)
 	if err != nil {
 		return nil, err
@@ -108,6 +113,11 @@ type walletSpendAction struct {
 func (keeper msgServer) WalletSpendAction(goCtx context.Context, msg *types.MsgWalletSpendAction) (*types.MsgWalletSpendActionResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
+	err := keeper.provisionIfNeeded(ctx, msg.Owner)
+	if err != nil {
+		return nil, err
+	}
+
 	action := &walletSpendAction{
 		Type:        "WALLET_SPEND_ACTION",
 		Owner:       msg.Owner.String(),
@@ -116,7 +126,7 @@ func (keeper msgServer) WalletSpendAction(goCtx context.Context, msg *types.MsgW
 		BlockTime:   ctx.BlockTime().Unix(),
 	}
 	// fmt.Fprintf(os.Stderr, "Context is %+v\n", ctx)
-	err := keeper.routeAction(ctx, msg, action)
+	err = keeper.routeAction(ctx, msg, action)
 	if err != nil {
 		return nil, err
 	}
@@ -125,9 +135,46 @@ func (keeper msgServer) WalletSpendAction(goCtx context.Context, msg *types.MsgW
 
 type provisionAction struct {
 	*types.MsgProvision
-	Type        string `json:"type"` // PLEASE_PROVISION
-	BlockHeight int64  `json:"blockHeight"`
-	BlockTime   int64  `json:"blockTime"`
+	Type          string `json:"type"` // PLEASE_PROVISION
+	BlockHeight   int64  `json:"blockHeight"`
+	BlockTime     int64  `json:"blockTime"`
+	AutoProvision bool   `json:"autoProvision"`
+}
+
+// provisionIfNeeded generates a provision action if no smart wallet is already
+// provisioned for the account. This assumes that all messages for
+// non-provisioned smart wallets allowed by the admission AnteHandler should
+// auto-provision the smart wallet.
+func (keeper msgServer) provisionIfNeeded(ctx sdk.Context, owner sdk.AccAddress) error {
+	// We need to generate a provision action until the smart wallet has
+	// been fully provisioned by the controller. This is because a provision is
+	// not guaranteed to succeed (e.g. lack of provision pool funds)
+	walletState := keeper.GetSmartWalletState(ctx, owner)
+	if walletState == types.SmartWalletStateProvisioned {
+		return nil
+	}
+
+	msg := &types.MsgProvision{
+		Address:    owner,
+		Submitter:  owner,
+		PowerFlags: []string{types.PowerFlagSmartWallet},
+	}
+
+	action := &provisionAction{
+		MsgProvision:  msg,
+		Type:          "PLEASE_PROVISION",
+		BlockHeight:   ctx.BlockHeight(),
+		BlockTime:     ctx.BlockTime().Unix(),
+		AutoProvision: true,
+	}
+
+	err := keeper.routeAction(ctx, msg, action)
+	// fmt.Fprintln(os.Stderr, "Returned from SwingSet", out, err)
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
 func (keeper msgServer) Provision(goCtx context.Context, msg *types.MsgProvision) (*types.MsgProvisionResponse, error) {

package/x/swingset/types/default-params.go

@@ -11,20 +11,24 @@ import (
 // experience if they don't.
 
 const (
-	BeansPerFeeUnit           = "feeUnit"
-	BeansPerInboundTx         = "inboundTx"
-	BeansPerBlockComputeLimit = "blockComputeLimit"
-	BeansPerMessage           = "message"
-	BeansPerMessageByte       = "messageByte"
-	BeansPerMinFeeDebit       = "minFeeDebit"
-	BeansPerStorageByte       = "storageByte"
-	BeansPerVatCreation       = "vatCreation"
-	BeansPerXsnapComputron    = "xsnapComputron"
+	BeansPerFeeUnit              = "feeUnit"
+	BeansPerInboundTx            = "inboundTx"
+	BeansPerBlockComputeLimit    = "blockComputeLimit"
+	BeansPerMessage              = "message"
+	BeansPerMessageByte          = "messageByte"
+	BeansPerMinFeeDebit          = "minFeeDebit"
+	BeansPerStorageByte          = "storageByte"
+	BeansPerVatCreation          = "vatCreation"
+	BeansPerXsnapComputron       = "xsnapComputron"
+	BeansPerSmartWalletProvision = "smartWalletProvision"
 
 	// QueueSize keys.
 	// Keep up-to-date with updateQueueAllowed() in packanges/cosmic-swingset/src/launch-chain.js
 	QueueInbound        = "inbound"
 	QueueInboundMempool = "inbound_mempool"
+
+	// PowerFlags.
+	PowerFlagSmartWallet = "SMART_WALLET"
 )
 
 var (
@@ -43,17 +47,18 @@ var (
 
 	// TODO: create the cost model we want, and update these to be more principled.
 	// These defaults currently make deploying an ag-solo cost less than $1.00.
-	DefaultBeansPerFeeUnit     = sdk.NewUint(1_000_000_000_000)                  // $1
-	DefaultBeansPerInboundTx   = DefaultBeansPerFeeUnit.Quo(sdk.NewUint(100))    // $0.01
-	DefaultBeansPerMessage     = DefaultBeansPerFeeUnit.Quo(sdk.NewUint(1_000))  // $0.001
-	DefaultBeansPerMessageByte = DefaultBeansPerFeeUnit.Quo(sdk.NewUint(50_000)) // $0.00002
-	DefaultBeansPerMinFeeDebit = DefaultBeansPerFeeUnit.Quo(sdk.NewUint(5))      // $0.2
-	DefaultBeansPerStorageByte = DefaultBeansPerFeeUnit.Quo(sdk.NewUint(500))    // $0.002
+	DefaultBeansPerFeeUnit              = sdk.NewUint(1_000_000_000_000)                  // $1
+	DefaultBeansPerInboundTx            = DefaultBeansPerFeeUnit.Quo(sdk.NewUint(100))    // $0.01
+	DefaultBeansPerMessage              = DefaultBeansPerFeeUnit.Quo(sdk.NewUint(1_000))  // $0.001
+	DefaultBeansPerMessageByte          = DefaultBeansPerFeeUnit.Quo(sdk.NewUint(50_000)) // $0.00002
+	DefaultBeansPerMinFeeDebit          = DefaultBeansPerFeeUnit.Quo(sdk.NewUint(5))      // $0.2
+	DefaultBeansPerStorageByte          = DefaultBeansPerFeeUnit.Quo(sdk.NewUint(500))    // $0.002
+	DefaultBeansPerSmartWalletProvision = DefaultBeansPerFeeUnit                          // $1
 
 	DefaultBootstrapVatConfig = "@agoric/vats/decentral-core-config.json"
 
 	DefaultPowerFlagFees = []PowerFlagFee{
-		NewPowerFlagFee("SMART_WALLET", sdk.NewCoins(sdk.NewInt64Coin("ubld", 10_000_000))),
+		NewPowerFlagFee(PowerFlagSmartWallet, sdk.NewCoins(sdk.NewInt64Coin("ubld", 10_000_000))),
 	}
 
 	DefaultInboundQueueMax = int32(1_000)
@@ -75,5 +80,6 @@ func DefaultBeansPerUnit() []StringBeans {
 		NewStringBeans(BeansPerStorageByte, DefaultBeansPerStorageByte),
 		NewStringBeans(BeansPerVatCreation, DefaultBeansPerVatCreation),
 		NewStringBeans(BeansPerXsnapComputron, DefaultBeansPerXsnapComputron),
+		NewStringBeans(BeansPerSmartWalletProvision, DefaultBeansPerSmartWalletProvision),
 	}
 }

package/x/swingset/types/expected_keepers.go

@@ -5,6 +5,15 @@ import (
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 )
 
+type SmartWalletState uint8
+
+const (
+	SmartWalletStateUnspecified SmartWalletState = iota
+	SmartWalletStateNone
+	SmartWalletStatePending
+	SmartWalletStateProvisioned
+)
+
 type AccountKeeper interface {
 	GetAccount(ctx sdk.Context, addr sdk.AccAddress) authtypes.AccountI
 	NewAccountWithAddress(ctx sdk.Context, addr sdk.AccAddress) authtypes.AccountI
@@ -15,4 +24,6 @@ type SwingSetKeeper interface {
 	GetBeansPerUnit(ctx sdk.Context) map[string]sdk.Uint
 	ChargeBeans(ctx sdk.Context, addr sdk.AccAddress, beans sdk.Uint) error
 	IsHighPriorityAddress(ctx sdk.Context, addr sdk.AccAddress) (bool, error)
+	GetSmartWalletState(ctx sdk.Context, addr sdk.AccAddress) SmartWalletState
+	ChargeForSmartWallet(ctx sdk.Context, addr sdk.AccAddress) error
 }

package/x/swingset/types/msgs.go

@@ -48,6 +48,33 @@ func chargeAdmission(ctx sdk.Context, keeper SwingSetKeeper, addr sdk.AccAddress
 	return keeper.ChargeBeans(ctx, addr, beans)
 }
 
+// checkSmartWalletProvisioned verifies if a smart wallet message (MsgWalletAction
+// and MsgWalletSpendAction) can be delivered for the owner's address. A message
+// is allowed if a smart wallet is already provisioned for the address, or if the
+// provisioning fee is charged successfully.
+// All messages for non-provisioned smart wallets allowed here will result in
+// an auto-provision action generated by the msg server.
+func checkSmartWalletProvisioned(ctx sdk.Context, keeper SwingSetKeeper, addr sdk.AccAddress) error {
+	walletState := keeper.GetSmartWalletState(ctx, addr)
+
+	switch walletState {
+	case SmartWalletStateProvisioned:
+		// The address already has a smart wallet
+		return nil
+	case SmartWalletStatePending:
+		// A provision (either explicit or automatic) may be pending execution in
+		// the controller, or if we ever allow multiple swingset messages per
+		// transaction, a previous message may have provisioned the wallet.
+		return nil
+	default:
+		// Charge for the smart wallet.
+		// This is a separate charge from the smart wallet action which triggered the check
+		// TODO: Currently this call does not mark the smart wallet provisioning as
+		// pending, resulting in multiple provisioning charges for the owner.
+		return keeper.ChargeForSmartWallet(ctx, addr)
+	}
+}
+
 func NewMsgDeliverInbound(msgs *Messages, submitter sdk.AccAddress) *MsgDeliverInbound {
 	return &MsgDeliverInbound{
 		Messages:  msgs.Messages,
@@ -137,6 +164,11 @@ func (msg MsgWalletAction) CheckAdmissibility(ctx sdk.Context, data interface{})
 		return sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "data must be a SwingSetKeeper, not a %T", data)
 	}
 
+	err := checkSmartWalletProvisioned(ctx, keeper, msg.Owner)
+	if err != nil {
+		return err
+	}
+
 	return chargeAdmission(ctx, keeper, msg.Owner, []string{msg.Action}, 0)
 }
 
@@ -204,6 +236,11 @@ func (msg MsgWalletSpendAction) CheckAdmissibility(ctx sdk.Context, data interfa
 		return sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "data must be a SwingSetKeeper, not a %T", data)
 	}
 
+	err := checkSmartWalletProvisioned(ctx, keeper, msg.Owner)
+	if err != nil {
+		return err
+	}
+
 	return chargeAdmission(ctx, keeper, msg.Owner, []string{msg.SpendAction}, 0)
 }
 
@@ -271,8 +308,12 @@ func (msg MsgProvision) ValidateBasic() error {
 
 // CheckAdmissibility implements the vm.ControllerAdmissionMsg interface.
 func (msg MsgProvision) CheckAdmissibility(ctx sdk.Context, data interface{}) error {
-	// We have our own fee charging mechanism within Swingset itself,
-	// so there are no admission restriction here.
+	// TODO: consider disallowing a provision message for a smart wallet if the
+	// smart wallet is already provisioned or pending provisioning. However we
+	// currently do not track whether a smart wallet is pending provisioning.
+
+	// For explicitly provisioning, swingset will take care of charging,
+	// so we skip admission fees.
 	return nil
 }
 

package/x/swingset/types/params.go

@@ -163,3 +163,77 @@ func validateQueueMax(i interface{}) error {
 	}
 	return nil
 }
+
+// UpdateParams appends any missing params, configuring them to their defaults,
+// then returning the updated params or an error. Existing params are not
+// modified, regardless of their value, and they are not removed if they no
+// longer appear in the defaults.
+func UpdateParams(params Params) (Params, error) {
+	newBpu, err := appendMissingDefaultBeansPerUnit(params.BeansPerUnit, DefaultBeansPerUnit())
+	if err != nil {
+		return params, err
+	}
+	newPff, err := appendMissingDefaultPowerFlagFees(params.PowerFlagFees, DefaultPowerFlagFees)
+	if err != nil {
+		return params, err
+	}
+	newQm, err := appendMissingDefaultQueueSize(params.QueueMax, DefaultQueueMax)
+	if err != nil {
+		return params, err
+	}
+
+	params.BeansPerUnit = newBpu
+	params.PowerFlagFees = newPff
+	params.QueueMax = newQm
+	return params, nil
+}
+
+// appendMissingDefaultBeansPerUnit appends the default beans per unit entries
+// not in the list of bean costs already, returning the possibly-updated list,
+// or an error.
+func appendMissingDefaultBeansPerUnit(bpu []StringBeans, defaultBpu []StringBeans) ([]StringBeans, error) {
+	existingBpu := make(map[string]struct{}, len(bpu))
+	for _, ob := range bpu {
+		existingBpu[ob.Key] = struct{}{}
+	}
+
+	for _, b := range defaultBpu {
+		if _, exists := existingBpu[b.Key]; !exists {
+			bpu = append(bpu, b)
+		}
+	}
+	return bpu, nil
+}
+
+// appendMissingDefaultPowerFlagFees appends the default power flag fee entries
+// not in the list of power flags already, returning the possibly-updated list,
+// or an error.
+func appendMissingDefaultPowerFlagFees(pff []PowerFlagFee, defaultPff []PowerFlagFee) ([]PowerFlagFee, error) {
+	existingPff := make(map[string]struct{}, len(pff))
+	for _, of := range pff {
+		existingPff[of.PowerFlag] = struct{}{}
+	}
+
+	for _, f := range defaultPff {
+		if _, exists := existingPff[f.PowerFlag]; !exists {
+			pff = append(pff, f)
+		}
+	}
+	return pff, nil
+}
+
+// appendMissingDefaultQueueSize appends the default queue size entries not in
+// the list of sizes already, returning the possibly-updated list, or an error.
+func appendMissingDefaultQueueSize(qs []QueueSize, defaultQs []QueueSize) ([]QueueSize, error) {
+	existingQs := make(map[string]struct{}, len(qs))
+	for _, os := range qs {
+		existingQs[os.Key] = struct{}{}
+	}
+
+	for _, s := range defaultQs {
+		if _, exists := existingQs[s.Key]; !exists {
+			qs = append(qs, s)
+		}
+	}
+	return qs, nil
+}

package/x/swingset/types/params_test.go

@@ -0,0 +1,116 @@
+package types
+
+import (
+	"reflect"
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+type beans = StringBeans
+
+func TestAddStorageBeanCost(t *testing.T) {
+	var defaultStorageCost beans
+	for _, b := range DefaultParams().BeansPerUnit {
+		if b.Key == BeansPerStorageByte {
+			defaultStorageCost = b
+		}
+	}
+	if defaultStorageCost.Key == "" {
+		t.Fatalf("no beans per storage byte in default params")
+	}
+
+	for _, tt := range []struct {
+		name string
+		in   []beans
+		want []beans
+	}{
+		{
+			name: "empty",
+			in:   []beans{},
+			want: []beans{defaultStorageCost},
+		},
+		{
+			name: "already_only_same",
+			in:   []beans{defaultStorageCost},
+			want: []beans{defaultStorageCost},
+		},
+		{
+			name: "already_only_different",
+			in:   []beans{NewStringBeans(BeansPerStorageByte, sdk.NewUint(123))},
+			want: []beans{NewStringBeans(BeansPerStorageByte, sdk.NewUint(123))},
+		},
+		{
+			name: "already_same",
+			in: []beans{
+				NewStringBeans("foo", sdk.NewUint(123)),
+				defaultStorageCost,
+				NewStringBeans("bar", sdk.NewUint(456)),
+			},
+			want: []beans{
+				NewStringBeans("foo", sdk.NewUint(123)),
+				defaultStorageCost,
+				NewStringBeans("bar", sdk.NewUint(456)),
+			},
+		},
+		{
+			name: "already_different",
+			in: []beans{
+				NewStringBeans("foo", sdk.NewUint(123)),
+				NewStringBeans(BeansPerStorageByte, sdk.NewUint(789)),
+				NewStringBeans("bar", sdk.NewUint(456)),
+			},
+			want: []beans{
+				NewStringBeans("foo", sdk.NewUint(123)),
+				NewStringBeans(BeansPerStorageByte, sdk.NewUint(789)),
+				NewStringBeans("bar", sdk.NewUint(456)),
+			},
+		},
+		{
+			name: "missing",
+			in: []beans{
+				NewStringBeans("foo", sdk.NewUint(123)),
+				NewStringBeans("bar", sdk.NewUint(456)),
+			},
+			want: []beans{
+				NewStringBeans("foo", sdk.NewUint(123)),
+				NewStringBeans("bar", sdk.NewUint(456)),
+				defaultStorageCost,
+			},
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := appendMissingDefaultBeansPerUnit(tt.in, []StringBeans{defaultStorageCost})
+			if err != nil {
+				t.Errorf("got error %v", err)
+			} else if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("want %v, got %v", tt.want, got)
+			}
+		})
+	}
+}
+
+func TestUpdateParams(t *testing.T) {
+
+	in := Params{
+		BeansPerUnit:       []beans{},
+		BootstrapVatConfig: "baz",
+		FeeUnitPrice:       sdk.NewCoins(sdk.NewInt64Coin("denom", 789)),
+		PowerFlagFees:      []PowerFlagFee{},
+		QueueMax:           []QueueSize{},
+	}
+	want := Params{
+		BeansPerUnit:       DefaultBeansPerUnit(),
+		BootstrapVatConfig: "baz",
+		FeeUnitPrice:       sdk.NewCoins(sdk.NewInt64Coin("denom", 789)),
+		PowerFlagFees:      DefaultPowerFlagFees,
+		QueueMax:           DefaultQueueMax,
+	}
+	got, err := UpdateParams(in)
+	if err != nil {
+		t.Fatalf("UpdateParam error %v", err)
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("got %v, want %v", got, want)
+	}
+}

package/x/vibc/ibc.go

@@ -7,11 +7,11 @@ import (
 	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	capability "github.com/cosmos/cosmos-sdk/x/capability/types"
-	channeltypes "github.com/cosmos/ibc-go/v3/modules/core/04-channel/types"
-	porttypes "github.com/cosmos/ibc-go/v3/modules/core/05-port/types"
-	host "github.com/cosmos/ibc-go/v3/modules/core/24-host"
+	channeltypes "github.com/cosmos/ibc-go/v4/modules/core/04-channel/types"
+	porttypes "github.com/cosmos/ibc-go/v4/modules/core/05-port/types"
+	host "github.com/cosmos/ibc-go/v4/modules/core/24-host"
 
-	"github.com/cosmos/ibc-go/v3/modules/core/exported"
+	"github.com/cosmos/ibc-go/v4/modules/core/exported"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
@@ -167,8 +167,8 @@ func (im IBCModule) OnChanOpenInit(
 	channelCap *capability.Capability,
 	counterparty channeltypes.Counterparty,
 	version string,
-) error {
-	return sdkerrors.Wrap(
+) (string, error) {
+	return "", sdkerrors.Wrap(
 		channeltypes.ErrChannelNotFound,
 		fmt.Sprintf("vibc does not allow synthetic channelOpenInit for port %s", portID),
 	)
@@ -224,15 +224,15 @@ func (im IBCModule) OnChanOpenTry(
 }
 
 type channelOpenAckEvent struct {
-	Type                  string                    `json:"type"`  // IBC
-	Event                 string                    `json:"event"` // channelOpenAck
-	PortID                string                    `json:"portID"`
-	ChannelID             string                    `json:"channelID"`
-	CounterpartyVersion   string                    `json:"counterpartyVersion"`
-	Counterparty          channeltypes.Counterparty `json:"counterparty"`
-	ConnectionHops        []string                  `json:"connectionHops"`
-	BlockHeight           int64                     `json:"blockHeight"`
-	BlockTime             int64                     `json:"blockTime"`
+	Type                string                    `json:"type"`  // IBC
+	Event               string                    `json:"event"` // channelOpenAck
+	PortID              string                    `json:"portID"`
+	ChannelID           string                    `json:"channelID"`
+	CounterpartyVersion string                    `json:"counterpartyVersion"`
+	Counterparty        channeltypes.Counterparty `json:"counterparty"`
+	ConnectionHops      []string                  `json:"connectionHops"`
+	BlockHeight         int64                     `json:"blockHeight"`
+	BlockTime           int64                     `json:"blockTime"`
 }
 
 func (im IBCModule) OnChanOpenAck(
@@ -248,15 +248,15 @@ func (im IBCModule) OnChanOpenAck(
 
 	channel.Counterparty.ChannelId = counterpartyChannelID
 	event := channelOpenAckEvent{
-		Type:                  "IBC_EVENT",
-		Event:                 "channelOpenAck",
-		PortID:                portID,
-		ChannelID:             channelID,
-		CounterpartyVersion:   counterpartyVersion,
-		Counterparty:          channel.Counterparty,
-		ConnectionHops:        channel.ConnectionHops,
-		BlockHeight:           ctx.BlockHeight(),
-		BlockTime:             ctx.BlockTime().Unix(),
+		Type:                "IBC_EVENT",
+		Event:               "channelOpenAck",
+		PortID:              portID,
+		ChannelID:           channelID,
+		CounterpartyVersion: counterpartyVersion,
+		Counterparty:        channel.Counterparty,
+		ConnectionHops:      channel.ConnectionHops,
+		BlockHeight:         ctx.BlockHeight(),
+		BlockTime:           ctx.BlockTime().Unix(),
 	}
 
 	return im.PushAction(ctx, event)
@@ -373,7 +373,7 @@ func (im IBCModule) OnRecvPacket(
 
 	err := im.PushAction(ctx, event)
 	if err != nil {
-		return channeltypes.NewErrorAcknowledgement(err.Error())
+		return channeltypes.NewErrorAcknowledgement(err)
 	}
 
 	return nil