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

package/x/swingset/keeper/msg_server.go

@@ -21,15 +21,13 @@ func NewMsgServerImpl(keeper Keeper) types.MsgServer {
 var _ types.MsgServer = msgServer{}
 
 type deliverInboundAction struct {
-	Type        string          `json:"type"`
-	Peer        string          `json:"peer"`
-	Messages    [][]interface{} `json:"messages"`
-	Ack         uint64          `json:"ack"`
-	BlockHeight int64           `json:"blockHeight"`
-	BlockTime   int64           `json:"blockTime"`
+	vm.ActionHeader `actionType:"DELIVER_INBOUND"`
+	Peer            string          `json:"peer"`
+	Messages        [][]interface{} `json:"messages"`
+	Ack             uint64          `json:"ack"`
 }
 
-func (keeper msgServer) routeAction(ctx sdk.Context, msg vm.ControllerAdmissionMsg, action vm.Jsonable) error {
+func (keeper msgServer) routeAction(ctx sdk.Context, msg vm.ControllerAdmissionMsg, action vm.Action) error {
 	isHighPriority, err := msg.IsHighPriority(ctx, keeper)
 	if err != nil {
 		return err
@@ -53,12 +51,9 @@ func (keeper msgServer) DeliverInbound(goCtx context.Context, msg *types.MsgDeli
 	}
 
 	action := &deliverInboundAction{
-		Type:        "DELIVER_INBOUND",
-		Peer:        msg.Submitter.String(),
-		Messages:    messages,
-		Ack:         msg.Ack,
-		BlockHeight: ctx.BlockHeight(),
-		BlockTime:   ctx.BlockTime().Unix(),
+		Peer:     msg.Submitter.String(),
+		Messages: messages,
+		Ack:      msg.Ack,
 	}
 
 	err := keeper.routeAction(ctx, msg, action)
@@ -70,26 +65,26 @@ func (keeper msgServer) DeliverInbound(goCtx context.Context, msg *types.MsgDeli
 }
 
 type walletAction struct {
-	Type        string `json:"type"` // WALLET_ACTION
-	Owner       string `json:"owner"`
-	Action      string `json:"action"`
-	BlockHeight int64  `json:"blockHeight"`
-	BlockTime   int64  `json:"blockTime"`
+	vm.ActionHeader `actionType:"WALLET_ACTION"`
+	Owner           string `json:"owner"`
+	Action          string `json:"action"`
 }
 
 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(),
-		Action:      msg.Action,
-		BlockHeight: ctx.BlockHeight(),
-		BlockTime:   ctx.BlockTime().Unix(),
+		Owner:  msg.Owner.String(),
+		Action: msg.Action,
 	}
 	// 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
@@ -98,25 +93,25 @@ func (keeper msgServer) WalletAction(goCtx context.Context, msg *types.MsgWallet
 }
 
 type walletSpendAction struct {
-	Type        string `json:"type"` // WALLET_SPEND_ACTION
-	Owner       string `json:"owner"`
-	SpendAction string `json:"spendAction"`
-	BlockHeight int64  `json:"blockHeight"`
-	BlockTime   int64  `json:"blockTime"`
+	vm.ActionHeader `actionType:"WALLET_SPEND_ACTION"`
+	Owner           string `json:"owner"`
+	SpendAction     string `json:"spendAction"`
 }
 
 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(),
 		SpendAction: msg.SpendAction,
-		BlockHeight: ctx.BlockHeight(),
-		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
 	}
@@ -124,10 +119,42 @@ func (keeper msgServer) WalletSpendAction(goCtx context.Context, msg *types.MsgW
 }
 
 type provisionAction struct {
+	vm.ActionHeader `actionType:"PLEASE_PROVISION"`
 	*types.MsgProvision
-	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,
+		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) {
@@ -140,9 +167,6 @@ func (keeper msgServer) Provision(goCtx context.Context, msg *types.MsgProvision
 
 	action := &provisionAction{
 		MsgProvision: msg,
-		Type:         "PLEASE_PROVISION",
-		BlockHeight:  ctx.BlockHeight(),
-		BlockTime:    ctx.BlockTime().Unix(),
 	}
 
 	// Create the account, if it doesn't already exist.
@@ -162,10 +186,8 @@ func (keeper msgServer) Provision(goCtx context.Context, msg *types.MsgProvision
 }
 
 type installBundleAction struct {
+	vm.ActionHeader `actionType:"INSTALL_BUNDLE"`
 	*types.MsgInstallBundle
-	Type        string `json:"type"` // INSTALL_BUNDLE
-	BlockHeight int64  `json:"blockHeight"`
-	BlockTime   int64  `json:"blockTime"`
 }
 
 func (keeper msgServer) InstallBundle(goCtx context.Context, msg *types.MsgInstallBundle) (*types.MsgInstallBundleResponse, error) {
@@ -177,9 +199,6 @@ func (keeper msgServer) InstallBundle(goCtx context.Context, msg *types.MsgInsta
 	}
 	action := &installBundleAction{
 		MsgInstallBundle: msg,
-		Type:             "INSTALL_BUNDLE",
-		BlockHeight:      ctx.BlockHeight(),
-		BlockTime:        ctx.BlockTime().Unix(),
 	}
 
 	err = keeper.routeAction(ctx, msg, action)

package/x/swingset/keeper/proposal.go

@@ -3,23 +3,19 @@ package keeper
 import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/types"
 )
 
 type coreEvalAction struct {
-	Type        string           `json:"type"` // CORE_EVAL
-	Evals       []types.CoreEval `json:"evals"`
-	BlockHeight int64            `json:"blockHeight"`
-	BlockTime   int64            `json:"blockTime"`
+	vm.ActionHeader `actionType:"CORE_EVAL"`
+	Evals           []types.CoreEval `json:"evals"`
 }
 
 // CoreEvalProposal tells SwingSet to evaluate the given JS code.
 func (k Keeper) CoreEvalProposal(ctx sdk.Context, p *types.CoreEvalProposal) error {
 	action := &coreEvalAction{
-		Type:        "CORE_EVAL",
-		Evals:       p.Evals,
-		BlockHeight: ctx.BlockHeight(),
-		BlockTime:   ctx.BlockTime().Unix(),
+		Evals: p.Evals,
 	}
 
 	return k.PushHighPriorityAction(ctx, action)

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/vbank/vbank.go

@@ -68,15 +68,15 @@ func (vbu vbankManyBalanceUpdates) Swap(i int, j int) {
 }
 
 type vbankBalanceUpdate struct {
-	Nonce   uint64                  `json:"nonce"`
-	Type    string                  `json:"type"`
-	Updated vbankManyBalanceUpdates `json:"updated"`
+	vm.ActionHeader `actionType:"VBANK_BALANCE_UPDATE"`
+	Nonce           uint64                  `json:"nonce"`
+	Updated         vbankManyBalanceUpdates `json:"updated"`
 }
 
 // getBalanceUpdate returns a bridge message containing the current bank balance
 // for the given addresses each for the specified denominations. Coins are used
 // only to track the set of denoms, not for the particular nonzero amounts.
-func getBalanceUpdate(ctx sdk.Context, keeper Keeper, addressToUpdate map[string]sdk.Coins) vm.Jsonable {
+func getBalanceUpdate(ctx sdk.Context, keeper Keeper, addressToUpdate map[string]sdk.Coins) vm.Action {
 	nentries := len(addressToUpdate)
 	if nentries == 0 {
 		return nil
@@ -84,7 +84,6 @@ func getBalanceUpdate(ctx sdk.Context, keeper Keeper, addressToUpdate map[string
 
 	nonce := keeper.GetNextSequence(ctx)
 	event := vbankBalanceUpdate{
-		Type:    "VBANK_BALANCE_UPDATE",
 		Nonce:   nonce,
 		Updated: make([]vbankSingleBalanceUpdate, 0, nentries),
 	}
@@ -111,7 +110,9 @@ func getBalanceUpdate(ctx sdk.Context, keeper Keeper, addressToUpdate map[string
 
 	// Ensure we have a deterministic order of updates.
 	sort.Sort(event.Updated)
-	return event
+
+	// Populate the event default fields (even though event does not embed vm.ActionHeader)
+	return vm.PopulateAction(ctx, event)
 }
 
 func marshal(event vm.Jsonable) ([]byte, error) {
@@ -242,7 +243,7 @@ func (ch portHandler) Receive(ctx *vm.ControllerContext, str string) (ret string
 	return
 }
 
-func (am AppModule) PushAction(ctx sdk.Context, action vm.Jsonable) error {
+func (am AppModule) PushAction(ctx sdk.Context, action vm.Action) error {
 	// vbank actions are not triggered by a swingset message in a transaction, so we need to
 	// synthesize unique context information.
 	// We use a fixed placeholder value for the txHash context, and can simply use `0` for the