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

package/vm/action.go

@@ -0,0 +1,133 @@
+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 returns a clone of action in which empty/zero-valued fields
+// in its embedded ActionHeader have been populated using the corresponding
+// `actionType:"..."` tag and the provided ctx, and its own empty/zero-valued
+// fields have been populated as specified by their `default:"..."` tags.
+func PopulateAction(ctx sdk.Context, action Action) Action {
+	oldActionDesc := reflect.Indirect(reflect.ValueOf(action))
+	if oldActionDesc.Kind() != reflect.Struct {
+		return action
+	}
+
+	// Shallow copy to a new value.
+	newActionDescPtr := reflect.New(oldActionDesc.Type())
+	newActionDesc := reflect.Indirect(newActionDescPtr)
+	for i := 0; i < newActionDesc.NumField(); i++ {
+		oldField := oldActionDesc.Field(i)
+		field := newActionDesc.Field(i)
+		fieldType := newActionDesc.Type().Field(i)
+		if !field.CanSet() {
+			continue
+		}
+
+		// Copy from original.
+		field.Set(oldField)
+
+		// Populate any ActionHeader struct.
+		var headerPtr *ActionHeader
+		if fieldType.Type == actionHeaderType {
+			headerPtr = field.Addr().Interface().(*ActionHeader)
+		} else if fieldType.Type == reflect.PtrTo(actionHeaderType) {
+			if field.IsNil() {
+				headerPtr = &ActionHeader{}
+			} else {
+				headerPtr = field.Interface().(*ActionHeader)
+			}
+		}
+		if headerPtr != nil {
+			actionTypeTag, _ := fieldType.Tag.Lookup("actionType")
+			newHeader := *headerPtr
+			SetActionHeaderFromContext(ctx, actionTypeTag, &newHeader)
+			if field.Kind() == reflect.Ptr {
+				field.Set(reflect.ValueOf(&newHeader))
+			} else {
+				field.Set(reflect.ValueOf(newHeader))
+			}
+			continue
+		}
+
+		// Skip any field that is already populated or lacks a "default" tag.
+		defaultTag, _ := fieldType.Tag.Lookup("default")
+		if !field.IsZero() || len(defaultTag) == 0 {
+			continue
+		}
+
+		// Populate the field from its "default" tag.
+		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 newActionDesc.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) {
+			toJson := func(in interface{}) string {
+				bz, err := json.Marshal(in)
+				if err != nil {
+					t.Fatal(err)
+				}
+				return string(bz)
+			}
+			jsonIn := toJson(tc.in)
+			out := vm.PopulateAction(tc.ctx, tc.in)
+			jsonIn2 := toJson(tc.in)
+			if jsonIn != jsonIn2 {
+				t.Errorf("unexpected mutated input: %s to %s", jsonIn, jsonIn2)
+			}
+			jsonOut := toJson(out)
+			jsonExpectedOut := toJson(tc.expectedOut)
+			if jsonOut != jsonExpectedOut {
+				t.Errorf("expected %s, got %s", jsonExpectedOut, jsonOut)
+			}
+		})
+	}
+}

package/vm/controller.go

@@ -1,16 +1,12 @@
 package vm
 
 import (
+	"context"
 	"fmt"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-type ControllerContext struct {
-	Context               sdk.Context
-	IBCChannelHandlerPort int
-}
-
 type ControllerAdmissionMsg interface {
 	sdk.Msg
 	CheckAdmissibility(sdk.Context, interface{}) error
@@ -25,16 +21,13 @@ 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
+var wrappedEmptySDKContext = sdk.WrapSDKContext(
+	sdk.Context{}.WithContext(context.Background()),
+)
+var controllerContext context.Context = wrappedEmptySDKContext
 
 type PortHandler interface {
-	Receive(*ControllerContext, string) (string, error)
+	Receive(context.Context, string) (string, error)
 }
 
 var portToHandler = make(map[int]PortHandler)
@@ -45,9 +38,9 @@ var lastPort = 0
 func SetControllerContext(ctx sdk.Context) func() {
 	// We are only called by the controller, so we assume that it is billing its
 	// own meter usage.
-	controllerContext.Context = ctx.WithGasMeter(sdk.NewInfiniteGasMeter())
+	controllerContext = sdk.WrapSDKContext(ctx.WithGasMeter(sdk.NewInfiniteGasMeter()))
 	return func() {
-		controllerContext.Context = sdk.Context{}
+		controllerContext = wrappedEmptySDKContext
 	}
 }
 
@@ -75,5 +68,5 @@ func ReceiveFromController(portNum int, msg string) (string, error) {
 	if handler == nil {
 		return "", fmt.Errorf("unregistered port %d", portNum)
 	}
-	return handler.Receive(&controllerContext, msg)
+	return handler.Receive(controllerContext, msg)
 }

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.
@@ -88,7 +88,7 @@ func (uva unlockedVestingAccount) TrackDelegation(blockTime time.Time, balance,
 // TrackUndelegation implements the vestexported.VestingAccount interface.
 func (uva unlockedVestingAccount) TrackUndelegation(amount sdk.Coins) {
 	// max(delegated - amount, 0) == delegated - min(delegated, amount)
-	uva.lien.Delegated = uva.lien.Delegated.Sub(uva.lien.Delegated.Min(amount))
+	uva.lien.Delegated = uva.lien.Delegated.Sub(uva.lien.Delegated.Min(amount)...)
 }
 
 // GetVestedCoins implements the vestexported.VestingAccount interface.
@@ -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.
@@ -206,12 +211,12 @@ func (la *LienAccount) LienedLockedCoins(ctx sdk.Context) sdk.Coins {
 	liened := la.lien.Coins
 	acc := la.omniClawbackAccount.(authtypes.AccountI)
 	if clawback, ok := acc.(vestexported.ClawbackVestingAccountI); ok {
-		liened = liened.Add(clawback.GetOriginalVesting().Sub(clawback.GetVestedOnly(ctx.BlockTime()))...)
+		liened = liened.Add(clawback.GetOriginalVesting().Sub(clawback.GetVestedOnly(ctx.BlockTime())...)...)
 	}
 	// Since coins can't go negative, even transiently, use the
 	// identity A + B = max(A, B) + min(A, B)
 	//    max(0, A - B) = max(B, A) - B = A - min(A, B)
-	return liened.Sub(liened.Min(delegated))
+	return liened.Sub(liened.Min(delegated)...)
 }
 
 // XXX_MessageName provides the message name for JSON serialization.

package/x/lien/keeper/keeper.go

@@ -7,6 +7,7 @@ import (
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/lien/types"
 
 	"github.com/cosmos/cosmos-sdk/codec"
+	storetypes "github.com/cosmos/cosmos-sdk/store/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	vestexported "github.com/cosmos/cosmos-sdk/x/auth/vesting/exported"
 	stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
@@ -31,7 +32,7 @@ type Keeper interface {
 // The accountKeeper field must be the same one that the bankKeeper and
 // stakingKeeper use.
 type keeperImpl struct {
-	key sdk.StoreKey
+	key storetypes.StoreKey
 	cdc codec.Codec
 
 	accountKeeper *types.WrappedAccountKeeper
@@ -43,7 +44,7 @@ type keeperImpl struct {
 
 // NewKeeper returns a new Keeper.
 // The ak must be the same accout keeper that the bk and sk use.
-func NewKeeper(cdc codec.Codec, key sdk.StoreKey, ak *types.WrappedAccountKeeper, bk types.BankKeeper, sk types.StakingKeeper,
+func NewKeeper(cdc codec.Codec, key storetypes.StoreKey, ak *types.WrappedAccountKeeper, bk types.BankKeeper, sk types.StakingKeeper,
 	pushAction vm.ActionPusher) Keeper {
 	return keeperImpl{
 		key:           key,
@@ -124,7 +125,7 @@ func (lk keeperImpl) ChangeLien(ctx sdk.Context, addr sdk.AccAddress, denom stri
 		return oldAmt, fmt.Errorf("lien delta of %s is larger than existing balance %s", delta, oldAmt)
 	}
 	newCoin := sdk.NewCoin(denom, newAmt)
-	newCoins := oldCoins.Sub(sdk.NewCoins(sdk.NewCoin(denom, oldAmt))).Add(newCoin)
+	newCoins := oldCoins.Sub(sdk.NewCoins(sdk.NewCoin(denom, oldAmt))...).Add(newCoin)
 	newLien := types.Lien{
 		Coins:     newCoins,
 		Delegated: oldLien.Delegated,
@@ -223,7 +224,7 @@ func (lk keeperImpl) getLockedUnvested(ctx sdk.Context, addr sdk.AccAddress) (sd
 		original := clawbackAccount.GetOriginalVesting()
 		unlocked := clawbackAccount.GetUnlockedOnly(ctx.BlockTime())
 		vested := clawbackAccount.GetVestedOnly(ctx.BlockTime())
-		return original.Sub(unlocked), original.Sub(vested)
+		return original.Sub(unlocked...), original.Sub(vested...)
 	}
 	if vestingAccount, ok := account.(vestexported.VestingAccount); ok {
 		return vestingAccount.GetVestingCoins(ctx.BlockTime()), sdk.NewCoins()

package/x/lien/keeper/keeper_test.go

@@ -99,7 +99,7 @@ func makeTestKit() testKit {
 		stakingtypes.NotBondedPoolName: {authtypes.Burner, authtypes.Staking},
 		authtypes.Minter:               {authtypes.Minter},
 	}
-	innerAk := authkeeper.NewAccountKeeper(cdc, authStoreKey, authSpace, authtypes.ProtoBaseAccount, maccPerms)
+	innerAk := authkeeper.NewAccountKeeper(cdc, authStoreKey, authSpace, authtypes.ProtoBaseAccount, maccPerms, "agoric")
 	wak := types.NewWrappedAccountKeeper(innerAk)
 
 	// bank keeper
@@ -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)
@@ -120,12 +120,12 @@ func makeTestKit() testKit {
 
 	db := dbm.NewMemDB()
 	ms := store.NewCommitMultiStore(db)
-	ms.MountStoreWithDB(paramsTKey, sdk.StoreTypeTransient, nil)
-	ms.MountStoreWithDB(paramsStoreKey, sdk.StoreTypeIAVL, db)
-	ms.MountStoreWithDB(authStoreKey, sdk.StoreTypeIAVL, db)
-	ms.MountStoreWithDB(bankStoreKey, sdk.StoreTypeIAVL, db)
-	ms.MountStoreWithDB(stakingStoreKey, sdk.StoreTypeIAVL, db)
-	ms.MountStoreWithDB(lienStoreKey, sdk.StoreTypeIAVL, db)
+	ms.MountStoreWithDB(paramsTKey, storetypes.StoreTypeTransient, nil)
+	ms.MountStoreWithDB(paramsStoreKey, storetypes.StoreTypeIAVL, db)
+	ms.MountStoreWithDB(authStoreKey, storetypes.StoreTypeIAVL, db)
+	ms.MountStoreWithDB(bankStoreKey, storetypes.StoreTypeIAVL, db)
+	ms.MountStoreWithDB(stakingStoreKey, storetypes.StoreTypeIAVL, db)
+	ms.MountStoreWithDB(lienStoreKey, storetypes.StoreTypeIAVL, db)
 	err := ms.LoadLatestVersion()
 	if err != nil {
 		panic(err)
@@ -165,7 +165,7 @@ func (tk testKit) initAccount(t *testing.T, funder, addr sdk.AccAddress, state t
 	}
 
 	// Total
-	toMint := state.Total.Sub(state.Locked)
+	toMint := state.Total.Sub(state.Locked...)
 	if !toMint.IsZero() {
 		err := tk.bankKeeper.MintCoins(tk.ctx, authtypes.Minter, toMint)
 		if err != nil {

package/x/lien/lien.go

@@ -5,6 +5,7 @@
 package lien
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"math"
@@ -70,7 +71,8 @@ const (
 // Receives and processes a bridge message, returning the
 // JSON-encoded response or error.
 // See spec/02_messages.md for the messages and responses.
-func (ch portHandler) Receive(ctx *vm.ControllerContext, str string) (string, error) {
+func (ch portHandler) Receive(cctx context.Context, str string) (string, error) {
+	ctx := sdk.UnwrapSDKContext(cctx)
 	var msg portMessage
 	err := json.Unmarshal([]byte(str), &msg)
 	if err != nil {
@@ -78,13 +80,13 @@ func (ch portHandler) Receive(ctx *vm.ControllerContext, str string) (string, er
 	}
 	switch msg.Type {
 	case LIEN_GET_ACCOUNT_STATE:
-		return ch.handleGetAccountState(ctx.Context, msg)
+		return ch.handleGetAccountState(ctx, msg)
 
 	case LIEN_GET_STAKING:
-		return ch.handleGetStaking(ctx.Context, msg)
+		return ch.handleGetStaking(ctx, msg)
 
 	case LIEN_CHANGE_LIENED:
-		return ch.handleChangeLiened(ctx.Context, msg)
+		return ch.handleChangeLiened(ctx, msg)
 	}
 	return "", fmt.Errorf("unrecognized type %s", msg.Type)
 }

package/x/lien/lien_test.go

@@ -1,11 +1,11 @@
 package lien
 
 import (
+	"context"
 	"encoding/json"
 	"reflect"
 	"testing"
 
-	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/lien/types"
 
 	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
@@ -97,7 +97,7 @@ func (m *mockLienKeeper) BondDenom(ctx sdk.Context) string {
 func (m *mockLienKeeper) GetAllBalances(ctx sdk.Context, addr sdk.AccAddress) sdk.Coins {
 	state := m.GetAccountState(ctx, addr)
 	delegated := state.Bonded.Add(state.Unbonding...)
-	bank := state.Total.Sub(state.Total.Min(delegated))
+	bank := state.Total.Sub(state.Total.Min(delegated)...)
 	return bank
 }
 
@@ -114,8 +114,8 @@ func (m *mockLienKeeper) GetDelegatorDelegations(ctx sdk.Context, delegator sdk.
 }
 
 func TestBadType(t *testing.T) {
-	ctx := sdk.Context{}
-	ctlCtx := &vm.ControllerContext{Context: ctx}
+	ctx := sdk.Context{}.WithContext(context.Background())
+	ctlCtx := sdk.WrapSDKContext(ctx)
 	keeper := mockLienKeeper{
 		states: map[string]types.AccountState{},
 	}
@@ -135,8 +135,8 @@ func TestBadType(t *testing.T) {
 }
 
 func TestGetAccountState(t *testing.T) {
-	ctx := sdk.Context{}
-	ctlCtx := &vm.ControllerContext{Context: ctx}
+	ctx := sdk.Context{}.WithContext(context.Background())
+	ctlCtx := sdk.WrapSDKContext(ctx)
 
 	keeper := mockLienKeeper{
 		states: map[string]types.AccountState{
@@ -177,8 +177,9 @@ func TestGetAccountState(t *testing.T) {
 }
 
 func TestGetAccountState_badRequest(t *testing.T) {
-	ctx := sdk.Context{}
-	ctlCtx := &vm.ControllerContext{Context: ctx}
+	ctx := sdk.Context{}.WithContext(context.Background())
+	ctlCtx := sdk.WrapSDKContext(ctx)
+
 	keeper := mockLienKeeper{
 		states: map[string]types.AccountState{},
 	}
@@ -214,8 +215,9 @@ func TestGetAccountState_badRequest(t *testing.T) {
 }
 
 func TestSetLiened_badAddr(t *testing.T) {
-	ctx := sdk.Context{}
-	ctlCtx := &vm.ControllerContext{Context: ctx}
+	ctx := sdk.Context{}.WithContext(context.Background())
+	ctlCtx := sdk.WrapSDKContext(ctx)
+
 	keeper := mockLienKeeper{}
 	ph := NewPortHandler(&keeper)
 	msg := portMessage{
@@ -235,8 +237,9 @@ func TestSetLiened_badAddr(t *testing.T) {
 }
 
 func TestSetLiened_badDenom(t *testing.T) {
-	ctx := sdk.Context{}
-	ctlCtx := &vm.ControllerContext{Context: ctx}
+	ctx := sdk.Context{}.WithContext(context.Background())
+	ctlCtx := sdk.WrapSDKContext(ctx)
+
 	keeper := mockLienKeeper{}
 	ph := NewPortHandler(&keeper)
 	msg := portMessage{
@@ -256,8 +259,9 @@ func TestSetLiened_badDenom(t *testing.T) {
 }
 
 func TestSetLiened(t *testing.T) {
-	ctx := sdk.Context{}
-	ctlCtx := &vm.ControllerContext{Context: ctx}
+	ctx := sdk.Context{}.WithContext(context.Background())
+	ctlCtx := sdk.WrapSDKContext(ctx)
+
 	keeper := mockLienKeeper{}
 	ph := NewPortHandler(&keeper)
 	msg := portMessage{
@@ -336,8 +340,8 @@ func TestGetStaking(t *testing.T) {
 	keeper.delegations[addr4.String()] = []stakingTypes.Delegation{}
 
 	ph := NewPortHandler(&keeper)
-	ctx := sdk.Context{}
-	ctlCtx := &vm.ControllerContext{Context: ctx}
+	ctx := sdk.Context{}.WithContext(context.Background())
+	ctlCtx := sdk.WrapSDKContext(ctx)
 
 	pi := func(x int64) *sdk.Int {
 		n := i(x)