@agoric/cosmos 0.35.0-u12.0 → 0.35.0-u14.0

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/swingset/types/proposal.go

@@ -5,7 +5,7 @@ import (
 	"strings"
 
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
-	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
+	govv1beta1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1"
 )
 
 const (
@@ -14,15 +14,15 @@ const (
 )
 
 var (
-	_ govtypes.Content = &CoreEvalProposal{}
+	_ govv1beta1.Content = &CoreEvalProposal{}
 )
 
 func init() {
-	govtypes.RegisterProposalType(ProposalTypeCoreEval)
+	govv1beta1.RegisterProposalType(ProposalTypeCoreEval)
 }
 
 // NewCoreEvalProposal creates a new core eval proposal.
-func NewCoreEvalProposal(title, description string, evals []CoreEval) govtypes.Content {
+func NewCoreEvalProposal(title, description string, evals []CoreEval) govv1beta1.Content {
 	return &CoreEvalProposal{
 		Title:       title,
 		Description: description,
@@ -44,7 +44,7 @@ func (cep *CoreEvalProposal) ProposalType() string { return ProposalTypeCoreEval
 
 // ValidateBasic runs basic stateless validity checks
 func (cep *CoreEvalProposal) ValidateBasic() error {
-	err := govtypes.ValidateAbstract(cep)
+	err := govv1beta1.ValidateAbstract(cep)
 	if err != nil {
 		return err
 	}

package/x/swingset/types/types.go

@@ -3,6 +3,7 @@ package types
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 
 	vstoragetypes "github.com/Agoric/agoric-sdk/golang/cosmos/x/vstorage/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -25,18 +26,16 @@ func NewEgress(nickname string, peer sdk.AccAddress, powerFlags []string) *Egres
 	}
 }
 
-// FIXME: Should have @endo/nat
+// Nat is analogous to @endo/nat
+// https://github.com/endojs/endo/blob/master/packages/nat
 func Nat(num float64) (uint64, error) {
-	if num < 0 {
-		return 0, errors.New("Not a natural")
-	}
-
-	nat := uint64(num)
-	if float64(nat) != num {
-		return 0, errors.New("Not a precise integer")
+	if 0 <= num && num < (1<<53) {
+		nat := uint64(num)
+		if float64(nat) == num {
+			return nat, nil
+		}
 	}
-
-	return nat, nil
+	return 0, errors.New("Not a Nat")
 }
 
 type Messages struct {
@@ -45,24 +44,26 @@ type Messages struct {
 	Ack      uint64
 }
 
-func UnmarshalMessagesJSON(jsonString string) (*Messages, error) {
-	// [message[], ack]
-	// message [num, body]
-	packet := make([]interface{}, 2)
-	err := json.Unmarshal([]byte(jsonString), &packet)
+// UnmarshalMessagesJSON decodes Messages from JSON text.
+// Input must represent an array in which the first element is an array of
+// [messageNum: integer, messageBody: string] pairs and the second element is
+// an "Ack" integer.
+func UnmarshalMessagesJSON(jsonString string) (ret *Messages, err error) {
+	packet := [2]interface{}{}
+	err = json.Unmarshal([]byte(jsonString), &packet)
 	if err != nil {
 		return nil, err
 	}
 
-	ret := &Messages{}
+	ret = &Messages{}
 
 	ackFloat, ok := packet[1].(float64)
 	if !ok {
-		return nil, errors.New("Ack is not an integer")
+		return nil, errors.New("Ack is not a number")
 	}
 	ret.Ack, err = Nat(ackFloat)
 	if err != nil {
-		return nil, err
+		return nil, errors.New("Ack is not a Nat")
 	}
 
 	msgs, ok := packet[0].([]interface{})
@@ -72,24 +73,25 @@ func UnmarshalMessagesJSON(jsonString string) (*Messages, error) {
 
 	ret.Messages = make([]string, len(msgs))
 	ret.Nums = make([]uint64, len(msgs))
-	for i, nummsgi := range msgs {
-		nummsg, ok := nummsgi.([]interface{})
-		if !ok || len(nummsg) != 2 {
-			return nil, errors.New("Message is not a pair")
+	for i, rawMsg := range msgs {
+		arrMsg, ok := rawMsg.([]interface{})
+		if !ok || len(arrMsg) != 2 {
+			return nil, fmt.Errorf("Messages[%d] is not a pair", i)
 		}
-		numFloat, ok := nummsg[0].(float64)
+
+		numFloat, ok := arrMsg[0].(float64)
 		if !ok {
-			return nil, errors.New("Message Num is not an integer")
+			return nil, fmt.Errorf("Messages[%d] Num is not a number", i)
 		}
 		ret.Nums[i], err = Nat(numFloat)
 		if err != nil {
-			return nil, errors.New("Message num is not a Nat")
+			return nil, fmt.Errorf("Messages[%d] Num is not a Nat", i)
 		}
-		msg, ok := nummsg[1].(string)
+
+		ret.Messages[i], ok = arrMsg[1].(string)
 		if !ok {
-			return nil, errors.New("Message is not a string")
+			return nil, fmt.Errorf("Messages[%d] body is not a string", i)
 		}
-		ret.Messages[i] = msg
 	}
 
 	return ret, nil

package/x/vbank/keeper/keeper.go

@@ -2,6 +2,7 @@ package keeper
 
 import (
 	"github.com/cosmos/cosmos-sdk/codec"
+	storetypes "github.com/cosmos/cosmos-sdk/store/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vbank/types"
@@ -15,7 +16,7 @@ const stateKey string = "state"
 
 // Keeper maintains the link to data storage and exposes getter/setter methods for the various parts of the state machine
 type Keeper struct {
-	storeKey   sdk.StoreKey
+	storeKey   storetypes.StoreKey
 	cdc        codec.Codec
 	paramSpace paramtypes.Subspace
 
@@ -27,7 +28,7 @@ type Keeper struct {
 
 // NewKeeper creates a new vbank Keeper instance
 func NewKeeper(
-	cdc codec.Codec, key sdk.StoreKey, paramSpace paramtypes.Subspace,
+	cdc codec.Codec, key storetypes.StoreKey, paramSpace paramtypes.Subspace,
 	accountKeeper types.AccountKeeper, bankKeeper types.BankKeeper,
 	rewardDistributorName string,
 	pushAction vm.ActionPusher,

package/x/vbank/keeper/querier.go

@@ -11,7 +11,11 @@ import (
 
 func NewQuerier(k Keeper, legacyQuerierCdc *codec.LegacyAmino) sdk.Querier {
 	return func(ctx sdk.Context, path []string, req abci.RequestQuery) ([]byte, error) {
-		switch path[0] {
+		var queryType string
+		if len(path) > 0 {
+			queryType = path[0]
+		}
+		switch queryType {
 		case types.QueryParams:
 			return queryParams(ctx, path[1:], req, k, legacyQuerierCdc)
 
@@ -19,7 +23,7 @@ func NewQuerier(k Keeper, legacyQuerierCdc *codec.LegacyAmino) sdk.Querier {
 			return queryState(ctx, path[1:], req, k, legacyQuerierCdc)
 
 		default:
-			return nil, sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unknown query path: %s", path[0])
+			return nil, sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unknown vbank query path")
 		}
 	}
 }

package/x/vbank/keeper/rewards.go

@@ -75,7 +75,7 @@ func (k Keeper) DistributeRewards(ctx sdk.Context) error {
 		}
 	}
 
-	state.RewardPool = state.RewardPool.Sub(xfer)
+	state.RewardPool = state.RewardPool.Sub(xfer...)
 	k.SetState(ctx, state)
 	return nil
 }

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) {
@@ -121,8 +122,9 @@ func marshal(event vm.Jsonable) ([]byte, error) {
 	return json.Marshal(event)
 }
 
-func (ch portHandler) Receive(ctx *vm.ControllerContext, str string) (ret string, err error) {
+func (ch portHandler) Receive(cctx context.Context, str string) (ret string, err error) {
 	// fmt.Println("vbank.go downcall", str)
+	ctx := sdk.UnwrapSDKContext(cctx)
 	keeper := ch.keeper
 
 	var msg portMessage
@@ -140,7 +142,7 @@ func (ch portHandler) Receive(ctx *vm.ControllerContext, str string) (ret string
 		if err = sdk.ValidateDenom(msg.Denom); err != nil {
 			return "", fmt.Errorf("invalid denom %s: %s", msg.Denom, err)
 		}
-		coin := keeper.GetBalance(ctx.Context, addr, msg.Denom)
+		coin := keeper.GetBalance(ctx, addr, msg.Denom)
 		packet := coin.Amount.String()
 		if err == nil {
 			bytes, err := json.Marshal(&packet)
@@ -162,12 +164,12 @@ func (ch portHandler) Receive(ctx *vm.ControllerContext, str string) (ret string
 			return "", fmt.Errorf("cannot convert %s to int", msg.Amount)
 		}
 		coins := sdk.NewCoins(sdk.NewCoin(msg.Denom, value))
-		if err := keeper.GrabCoins(ctx.Context, addr, coins); err != nil {
+		if err := keeper.GrabCoins(ctx, addr, coins); err != nil {
 			return "", fmt.Errorf("cannot grab %s coins: %s", coins.Sort().String(), err)
 		}
 		addressToBalances := make(map[string]sdk.Coins, 1)
 		addressToBalances[msg.Sender] = sdk.NewCoins(sdk.NewInt64Coin(msg.Denom, 1))
-		bz, err := marshal(getBalanceUpdate(ctx.Context, keeper, addressToBalances))
+		bz, err := marshal(getBalanceUpdate(ctx, keeper, addressToBalances))
 		if err != nil {
 			return "", err
 		}
@@ -190,12 +192,12 @@ func (ch portHandler) Receive(ctx *vm.ControllerContext, str string) (ret string
 			return "", fmt.Errorf("cannot convert %s to int", msg.Amount)
 		}
 		coins := sdk.NewCoins(sdk.NewCoin(msg.Denom, value))
-		if err := keeper.SendCoins(ctx.Context, addr, coins); err != nil {
+		if err := keeper.SendCoins(ctx, addr, coins); err != nil {
 			return "", fmt.Errorf("cannot give %s coins: %s", coins.Sort().String(), err)
 		}
 		addressToBalances := make(map[string]sdk.Coins, 1)
 		addressToBalances[msg.Recipient] = sdk.NewCoins(sdk.NewInt64Coin(msg.Denom, 1))
-		bz, err := marshal(getBalanceUpdate(ctx.Context, keeper, addressToBalances))
+		bz, err := marshal(getBalanceUpdate(ctx, keeper, addressToBalances))
 		if err != nil {
 			return "", err
 		}
@@ -211,20 +213,20 @@ func (ch portHandler) Receive(ctx *vm.ControllerContext, str string) (ret string
 			return "", fmt.Errorf("cannot convert %s to int", msg.Amount)
 		}
 		coins := sdk.NewCoins(sdk.NewCoin(msg.Denom, value))
-		if err := keeper.StoreRewardCoins(ctx.Context, coins); err != nil {
+		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.Context)
+		state := keeper.GetState(ctx)
 		state.RewardPool = state.RewardPool.Add(coins...)
-		keeper.SetState(ctx.Context, state)
+		keeper.SetState(ctx, state)
 		// We don't supply the module balance, since the controller shouldn't know.
 		ret = "true"
 
 	case "VBANK_GET_MODULE_ACCOUNT_ADDRESS":
-		addr := keeper.GetModuleAccountAddress(ctx.Context, msg.ModuleName).String()
+		addr := keeper.GetModuleAccountAddress(ctx, msg.ModuleName).String()
 		if len(addr) == 0 {
 			return "", fmt.Errorf("module account %s not found", msg.ModuleName)
 		}
@@ -242,7 +244,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

package/x/vbank/vbank_test.go

@@ -250,7 +250,7 @@ func (b *mockBank) SendCoinsFromModuleToModule(ctx sdk.Context, senderModule, re
 func makeTestKit(account types.AccountKeeper, bank types.BankKeeper) (Keeper, sdk.Context) {
 	encodingConfig := params.MakeEncodingConfig()
 	cdc := encodingConfig.Marshaler
-	pushAction := func(ctx sdk.Context, action vm.Jsonable) error {
+	pushAction := func(ctx sdk.Context, action vm.Action) error {
 		return nil
 	}
 
@@ -263,9 +263,9 @@ func makeTestKit(account types.AccountKeeper, bank types.BankKeeper) (Keeper, sd
 
 	db := dbm.NewMemDB()
 	ms := store.NewCommitMultiStore(db)
-	ms.MountStoreWithDB(vbankStoreKey, sdk.StoreTypeIAVL, db)
-	ms.MountStoreWithDB(paramsStoreKey, sdk.StoreTypeIAVL, db)
-	ms.MountStoreWithDB(paramsTStoreKey, sdk.StoreTypeTransient, db)
+	ms.MountStoreWithDB(vbankStoreKey, storetypes.StoreTypeIAVL, db)
+	ms.MountStoreWithDB(paramsStoreKey, storetypes.StoreTypeIAVL, db)
+	ms.MountStoreWithDB(paramsTStoreKey, storetypes.StoreTypeTransient, db)
 	err := ms.LoadLatestVersion()
 	if err != nil {
 		panic(err)
@@ -284,7 +284,7 @@ func Test_Receive_GetBalance(t *testing.T) {
 	}}
 	keeper, ctx := makeTestKit(nil, bank)
 	ch := NewPortHandler(AppModule{}, keeper)
-	ctlCtx := &vm.ControllerContext{Context: ctx}
+	ctlCtx := sdk.WrapSDKContext(ctx)
 
 	ret, err := ch.Receive(ctlCtx, `{
 		"type": "VBANK_GET_BALANCE",
@@ -312,7 +312,7 @@ func Test_Receive_Give(t *testing.T) {
 	}}
 	keeper, ctx := makeTestKit(nil, bank)
 	ch := NewPortHandler(AppModule{}, keeper)
-	ctlCtx := &vm.ControllerContext{Context: ctx}
+	ctlCtx := sdk.WrapSDKContext(ctx)
 
 	ret, err := ch.Receive(ctlCtx, `{
 		"type": "VBANK_GIVE",
@@ -349,7 +349,7 @@ func Test_Receive_GiveToRewardDistributor(t *testing.T) {
 	bank := &mockBank{}
 	keeper, ctx := makeTestKit(nil, bank)
 	ch := NewPortHandler(AppModule{}, keeper)
-	ctlCtx := &vm.ControllerContext{Context: ctx}
+	ctlCtx := sdk.WrapSDKContext(ctx)
 
 	tests := []struct {
 		name          string
@@ -474,7 +474,7 @@ func Test_Receive_Grab(t *testing.T) {
 	}}
 	keeper, ctx := makeTestKit(nil, bank)
 	ch := NewPortHandler(AppModule{}, keeper)
-	ctlCtx := &vm.ControllerContext{Context: ctx}
+	ctlCtx := sdk.WrapSDKContext(ctx)
 
 	ret, err := ch.Receive(ctlCtx, `{
 		"type": "VBANK_GRAB",
@@ -517,16 +517,16 @@ func Test_EndBlock_Events(t *testing.T) {
 	}}
 	acct := &mockAuthKeeper{
 		accounts: map[string]authtypes.AccountI{
-			addr1: &authtypes.ModuleAccount{BaseAccount: &authtypes.BaseAccount{ Address: addr1 }},
-			addr2: &authtypes.ModuleAccount{BaseAccount: &authtypes.BaseAccount{ Address: addr2 }},
-			addr3: &authtypes.BaseAccount{ Address: addr3 },
+			addr1: &authtypes.ModuleAccount{BaseAccount: &authtypes.BaseAccount{Address: addr1}},
+			addr2: &authtypes.ModuleAccount{BaseAccount: &authtypes.BaseAccount{Address: addr2}},
+			addr3: &authtypes.BaseAccount{Address: addr3},
 		},
 	}
 	keeper, ctx := makeTestKit(acct, bank)
 	// Turn off rewards.
 	keeper.SetParams(ctx, types.Params{PerEpochRewardFraction: sdk.ZeroDec()})
 	msgsSent := []string{}
-	keeper.PushAction = func(ctx sdk.Context, action vm.Jsonable) error {
+	keeper.PushAction = func(ctx sdk.Context, action vm.Action) error {
 		bz, err := json.Marshal(action)
 		if err != nil {
 			return err
@@ -630,7 +630,7 @@ func Test_EndBlock_Rewards(t *testing.T) {
 	}
 	keeper, ctx := makeTestKit(nil, bank)
 	msgsSent := []string{}
-	keeper.PushAction = func(ctx sdk.Context, action vm.Jsonable) error {
+	keeper.PushAction = func(ctx sdk.Context, action vm.Action) error {
 		bz, err := json.Marshal(action)
 		if err != nil {
 			return err
@@ -746,7 +746,7 @@ func Test_EndBlock_Rewards(t *testing.T) {
 	}
 }
 
-type mockAuthKeeper struct{
+type mockAuthKeeper struct {
 	accounts map[string]authtypes.AccountI
 	modAddrs map[string]string
 }
@@ -754,11 +754,11 @@ type mockAuthKeeper struct{
 func (ma mockAuthKeeper) GetModuleAccount(ctx sdk.Context, name string) authtypes.ModuleAccountI {
 	addr, ok := ma.modAddrs[name]
 	if !ok {
-			return nil
+		return nil
 	}
 	acct, ok := ma.accounts[addr]
 	if !ok {
-			panic("missing module account")
+		panic("missing module account")
 	}
 	return acct.(authtypes.ModuleAccountI)
 }
@@ -778,7 +778,7 @@ func Test_Module_Account(t *testing.T) {
 	acct := &mockAuthKeeper{
 		accounts: map[string]authtypes.AccountI{
 			moduleBech32: authtypes.NewEmptyModuleAccount("vbank/reserve"),
-			addr1: authtypes.NewBaseAccountWithAddress(sdk.MustAccAddressFromBech32(addr1)),
+			addr1:        authtypes.NewBaseAccountWithAddress(sdk.MustAccAddressFromBech32(addr1)),
 		},
 		modAddrs: map[string]string{
 			"vbank/reserve": moduleBech32,
@@ -787,7 +787,7 @@ func Test_Module_Account(t *testing.T) {
 	keeper, ctx := makeTestKit(acct, nil)
 	am := AppModule{keeper: keeper}
 	ch := NewPortHandler(am, keeper)
-	ctlCtx := &vm.ControllerContext{Context: ctx}
+	ctlCtx := sdk.WrapSDKContext(ctx)
 
 	mod1 := "vbank/reserve"
 	ret, err := ch.Receive(ctlCtx, `{

package/x/vibc/handler.go

@@ -3,6 +3,7 @@ package vibc
 import (
 	"fmt"
 
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
@@ -23,10 +24,8 @@ func NewHandler(keeper Keeper) sdk.Handler {
 
 type sendPacketAction struct {
 	*MsgSendPacket
-	Type        string `json:"type"`  // IBC_EVENT
-	Event       string `json:"event"` // sendPacket
-	BlockHeight int64  `json:"blockHeight"`
-	BlockTime   int64  `json:"blockTime"`
+	vm.ActionHeader `actionType:"IBC_EVENT"`
+	Event           string `json:"event" default:"sendPacket"`
 }
 
 func handleMsgSendPacket(ctx sdk.Context, keeper Keeper, msg *MsgSendPacket) (*sdk.Result, error) {
@@ -41,10 +40,6 @@ func handleMsgSendPacket(ctx sdk.Context, keeper Keeper, msg *MsgSendPacket) (*s
 
 	action := &sendPacketAction{
 		MsgSendPacket: msg,
-		Type:          "IBC_EVENT",
-		Event:         "sendPacket",
-		BlockHeight:   ctx.BlockHeight(),
-		BlockTime:     ctx.BlockTime().Unix(),
 	}
 	// fmt.Fprintf(os.Stderr, "Context is %+v\n", ctx)