@agoric/cosmos 0.34.2-dev-7ffae88.0 → 0.34.2-orchestration-dev-096c4e8.0

package/x/vlocalchain/vlocalchain.go

@@ -0,0 +1,109 @@
+package vlocalchain
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/gogo/protobuf/jsonpb"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vlocalchain/keeper"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vlocalchain/types"
+)
+
+var _ vm.PortHandler = (*portHandler)(nil)
+
+type portHandler struct {
+	keeper keeper.Keeper
+}
+
+type portMessage struct {
+	Type     string          `json:"type"`
+	Address  string          `json:"address,omitempty"`
+	Messages json.RawMessage `json:"messages,omitempty"`
+}
+
+func NewReceiver(keeper keeper.Keeper) portHandler {
+	return portHandler{keeper: keeper}
+}
+
+func (h portHandler) Receive(cctx context.Context, str string) (ret string, err error) {
+	var msg portMessage
+	err = json.Unmarshal([]byte(str), &msg)
+	if err != nil {
+		return
+	}
+
+	switch msg.Type {
+	case "VLOCALCHAIN_ALLOCATE_ADDRESS":
+		addr := h.keeper.AllocateAddress(cctx)
+		var bz []byte
+		if bz, err = json.Marshal(addr.String()); err != nil {
+			return
+		}
+		ret = string(bz)
+
+	case "VLOCALCHAIN_QUERY":
+		// Copy the JSON messages string into a CosmosTx object so we can
+		// deserialize it with just proto3 JSON.
+		cosmosTxBz := []byte(`{"messages":` + string(msg.Messages) + `}`)
+
+		var qms []types.QueryRequest
+		qms, err = h.keeper.DeserializeRequests(cosmosTxBz)
+		if err != nil {
+			return
+		}
+
+		// We need jsonpb for its access to the global registry.
+		marshaller := jsonpb.Marshaler{EmitDefaults: true, OrigName: true}
+
+		var s string
+		resps := make([]json.RawMessage, len(qms))
+		for i, qm := range qms {
+			var qr *types.QueryResponse
+			qr, err = h.keeper.Query(cctx, qm)
+			if err != nil {
+				return
+			}
+			if s, err = marshaller.MarshalToString(qr); err != nil {
+				return
+			}
+			resps[i] = []byte(s)
+		}
+
+		var bz []byte
+		if bz, err = json.Marshal(resps); err != nil {
+			return
+		}
+		ret = string(bz)
+
+	case "VLOCALCHAIN_EXECUTE_TX":
+		origCtx := sdk.UnwrapSDKContext(cctx)
+
+		// Copy the JSON messages string into a CosmosTx object so we can
+		// deserialize it with just proto3 JSON.
+		cosmosTxBz := []byte(`{"messages":` + string(msg.Messages) + `}`)
+
+		var msgs []sdk.Msg
+		if msgs, err = h.keeper.DeserializeTxMessages(cosmosTxBz); err != nil {
+			return
+		}
+
+		var resps []interface{}
+		resps, err = h.keeper.ExecuteTx(origCtx, msg.Address, msgs)
+		if err != nil {
+			return
+		}
+
+		var bz []byte
+		if bz, err = json.Marshal(resps); err != nil {
+			return
+		}
+		ret = string(bz)
+	default:
+		err = fmt.Errorf("unrecognized message type %s", msg.Type)
+	}
+	return
+}

package/x/vlocalchain/vlocalchain_test.go

@@ -0,0 +1,305 @@
+package vlocalchain_test
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/app/params"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vlocalchain"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vlocalchain/types"
+
+	"github.com/cosmos/cosmos-sdk/baseapp"
+	"github.com/cosmos/cosmos-sdk/store"
+	storetypes "github.com/cosmos/cosmos-sdk/store/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+	transfertypes "github.com/cosmos/ibc-go/v6/modules/apps/transfer/types"
+	"github.com/tendermint/tendermint/libs/log"
+
+	"github.com/gogo/protobuf/jsonpb"
+	"github.com/gogo/protobuf/proto"
+	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+	dbm "github.com/tendermint/tm-db"
+)
+
+var (
+	vlocalchainStoreKey = sdk.NewKVStoreKey(types.StoreKey)
+)
+
+const (
+	firstAddr          = "cosmos1uupflqrldlpkktssnzgp3r03ff6kz4u4kzd92pjgsfddye7grrlqt9rmmt"
+	msgAllocateAddress = `{"type":"VLOCALCHAIN_ALLOCATE_ADDRESS"}`
+)
+
+type mockBank struct {
+	banktypes.UnimplementedQueryServer
+	banktypes.UnimplementedMsgServer
+	balances   map[string]sdk.Coins
+	failToSend error
+}
+
+var _ banktypes.QueryServer = (*mockBank)(nil)
+var _ banktypes.MsgServer = (*mockBank)(nil)
+
+func (b *mockBank) AllBalances(cctx context.Context, req *banktypes.QueryAllBalancesRequest) (*banktypes.QueryAllBalancesResponse, error) {
+	addr, err := sdk.AccAddressFromBech32(req.Address)
+	if err != nil {
+		return nil, err
+	}
+
+	var resp banktypes.QueryAllBalancesResponse
+	resp.Balances = sdk.Coins{}
+	if coins, ok := b.balances[addr.String()]; ok {
+		resp.Balances = coins
+	}
+	return &resp, nil
+}
+
+func (b *mockBank) Send(cctx context.Context, req *banktypes.MsgSend) (*banktypes.MsgSendResponse, error) {
+	if b.failToSend != nil {
+		return nil, b.failToSend
+	}
+	return &banktypes.MsgSendResponse{}, nil
+}
+
+type mockTransfer struct {
+	transfertypes.UnimplementedQueryServer
+	transfertypes.UnimplementedMsgServer
+}
+
+var _ transfertypes.QueryServer = (*mockTransfer)(nil)
+var _ transfertypes.MsgServer = (*mockTransfer)(nil)
+
+func (t *mockTransfer) Transfer(cctx context.Context, msg *transfertypes.MsgTransfer) (*transfertypes.MsgTransferResponse, error) {
+	return &transfertypes.MsgTransferResponse{Sequence: 1}, nil
+}
+
+// makeTestKit creates a minimal Keeper and Context for use in testing.
+func makeTestKit(bank *mockBank, transfer *mockTransfer) (vm.PortHandler, context.Context) {
+	encodingConfig := params.MakeEncodingConfig()
+	cdc := encodingConfig.Marshaler
+
+	txRouter := baseapp.NewMsgServiceRouter()
+	txRouter.SetInterfaceRegistry(encodingConfig.InterfaceRegistry)
+	queryRouter := baseapp.NewGRPCQueryRouter()
+	queryRouter.SetInterfaceRegistry(encodingConfig.InterfaceRegistry)
+
+	banktypes.RegisterInterfaces(encodingConfig.InterfaceRegistry)
+	banktypes.RegisterMsgServer(txRouter, bank)
+	banktypes.RegisterQueryServer(queryRouter, bank)
+	transfertypes.RegisterInterfaces(encodingConfig.InterfaceRegistry)
+	transfertypes.RegisterMsgServer(txRouter, transfer)
+	transfertypes.RegisterQueryServer(queryRouter, transfer)
+
+	// create a new Keeper
+	keeper := vlocalchain.NewKeeper(cdc, vlocalchainStoreKey, txRouter, queryRouter)
+
+	db := dbm.NewMemDB()
+	ms := store.NewCommitMultiStore(db)
+	ms.MountStoreWithDB(vlocalchainStoreKey, storetypes.StoreTypeIAVL, db)
+	err := ms.LoadLatestVersion()
+	if err != nil {
+		panic(err)
+	}
+
+	// create a new SDK Context
+	ctx := sdk.NewContext(ms, tmproto.Header{}, false, log.NewNopLogger()).WithBlockHeight(998)
+
+	handler := vm.NewProtectedPortHandler(vlocalchain.NewReceiver(keeper))
+
+	// create a new Go context
+	cctx := sdk.WrapSDKContext(ctx)
+	return handler, cctx
+}
+
+func TestAllocateAddress(t *testing.T) {
+	bank := &mockBank{}
+	transfer := &mockTransfer{}
+	handler, cctx := makeTestKit(bank, transfer)
+
+	addrs := map[string]bool{
+		firstAddr: false,
+		"cosmos1yj40fakym8kf4wvgz9tky7k9f3v9msm3t7frscrmkjsdkxkpsfkqgeczkg": false,
+		"cosmos1s76vryj7m8k8nm9le65a4plhf5rym5sumtt2n0vwnk5l6k4cwuhsj56ujj": false,
+		"cosmos1c5hplwyxk5jr2dsygjqepzfqvfukwduq9c4660aah76krf99m6gs0k7hvl": false,
+		"cosmos1ys3a7mtna3cad0wxcs4ddukn37stexjdvns8jfdn4uerlr95y4xqnrypf6": false,
+	}
+	numToTest := len(addrs)
+	for i := 0; i < numToTest; i++ {
+		// receive the message
+		ret, err := handler.Receive(cctx, msgAllocateAddress)
+		if err != nil {
+			t.Fatalf("unexpected error[%d]: %v", i, err)
+		}
+		if ret == "" {
+			t.Fatalf("expected non-empty address[%d]", i)
+		}
+		var addr string
+		if err := json.Unmarshal([]byte(ret), &addr); err != nil {
+			t.Fatalf("unexpected error unmarshalling address string[%d]: %v: %v", i, ret, err)
+		}
+
+		already, ok := addrs[addr]
+		if !ok {
+			t.Fatalf("unexpected address[%d]: %v", i, addr)
+		}
+		if already {
+			t.Fatalf("unexpected duplicate address[%d]: %v", i, addr)
+		}
+		addrs[addr] = true
+	}
+}
+
+func TestQuery(t *testing.T) {
+	alreadyAddr := sdk.MustBech32ifyAddressBytes("cosmos", []byte("already"))
+	nonexistentAddr := sdk.MustBech32ifyAddressBytes("cosmos", []byte("nonexistent"))
+	bank := &mockBank{balances: map[string]sdk.Coins{
+		firstAddr:   []sdk.Coin{sdk.NewCoin("fresh", sdk.NewInt(123))},
+		alreadyAddr: []sdk.Coin{sdk.NewCoin("stale", sdk.NewInt(321))},
+	}}
+	transfer := &mockTransfer{}
+	handler, cctx := makeTestKit(bank, transfer)
+
+	// get balances
+	testCases := []struct {
+		name     string
+		addr     string
+		failure  string
+		expected sdk.Coins
+	}{
+		{"nonexistent", nonexistentAddr, "", sdk.Coins{}},
+		{"already", alreadyAddr, "", bank.balances[alreadyAddr]},
+		{"first", firstAddr, "", bank.balances[firstAddr]},
+		{"badaddr", "cosmos11111111111", "decoding bech32 failed: invalid separator index 16", sdk.Coins{}},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		ctx := sdk.UnwrapSDKContext(cctx)
+		t.Run(tc.name, func(t *testing.T) {
+			msgGetBalances := `{"type":"VLOCALCHAIN_QUERY","messages":[{"@type":"/cosmos.bank.v1beta1.QueryAllBalancesRequest","address":"` + tc.addr + `"}]}`
+			t.Logf("query request: %v", msgGetBalances)
+			ret, err := handler.Receive(cctx, msgGetBalances)
+			t.Logf("query response: %v", ret)
+			if tc.failure != "" {
+				if err == nil {
+					t.Fatalf("expected error %v, not nil with return %v", tc.failure, ret)
+				} else if err.Error() != tc.failure {
+					t.Fatalf("expected error %v, not %v", tc.failure, err)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if err == nil && ret == "" {
+				t.Fatalf("expected non-empty json")
+			}
+
+			// Unmarshal the responses.
+			s := `{"responses":` + ret + `}`
+
+			unmarshaler := jsonpb.Unmarshaler{}
+			var qrs types.QueryResponses
+			if err = unmarshaler.Unmarshal(strings.NewReader(s), &qrs); err != nil {
+				t.Fatalf("unexpected error unmarshalling reply: %v: %v", ret, err)
+			}
+
+			resps := qrs.Responses
+			if len(resps) != 1 {
+				t.Fatalf("expected responses length 1, got %v", len(resps))
+			}
+			if resps[0].Error != "" {
+				t.Fatalf("unexpected error response: %v", resps[0].Error)
+			}
+			if resps[0].Height != ctx.BlockHeight() {
+				t.Fatalf("expected height %v, got %v", ctx.BlockHeight(), resps[0].Height)
+			}
+
+			// Unmarshal the Any.
+			var pb banktypes.QueryAllBalancesResponse
+			if err = proto.Unmarshal(resps[0].Reply.Value, &pb); err != nil {
+				t.Fatalf("unexpected error unmarshalling reply: %v: %v", ret, err)
+			}
+
+			if !pb.Balances.IsEqual(tc.expected) {
+				t.Errorf("unexpected balance: expected %v, got %v", tc.expected, pb.Balances)
+			}
+		})
+	}
+}
+
+func TestExecuteTx(t *testing.T) {
+	alreadyAddr := sdk.MustBech32ifyAddressBytes("cosmos", []byte("already"))
+	bank := &mockBank{balances: map[string]sdk.Coins{
+		firstAddr:   []sdk.Coin{sdk.NewCoin("fresh", sdk.NewInt(123))},
+		alreadyAddr: []sdk.Coin{sdk.NewCoin("stale", sdk.NewInt(321))},
+	}}
+	transfer := &mockTransfer{}
+	handler, cctx := makeTestKit(bank, transfer)
+
+	// create a new message
+	msg := `{"type":"VLOCALCHAIN_ALLOCATE_ADDRESS"}`
+	ret, err := handler.Receive(cctx, msg)
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if ret == "" {
+		t.Fatalf("expected non-empty json")
+	}
+	var addr string
+	if err := json.Unmarshal([]byte(ret), &addr); err != nil {
+		t.Fatalf("unexpected error unmarshalling address string: %v: %s", ret, err)
+	}
+	if addr != firstAddr {
+		t.Fatalf("expected address %v, got %v", firstAddr, addr)
+	}
+
+	testCases := []struct {
+		name          string
+		signerAddress string
+		fromAddress   string
+		toAddress     string
+		failure       string
+	}{
+		{"valid", addr, addr, alreadyAddr, ""},
+		{"parse error", `"` + addr, firstAddr, alreadyAddr, "invalid character 'c' after object key:value pair"},
+		{"invalid address", addr, alreadyAddr, alreadyAddr, "required signer cosmos1v9k8yetpv3us7src8u does not match actual signer"},
+		{"unauth", alreadyAddr, addr, alreadyAddr, "required signer cosmos1uupflqrldlpkktssnzgp3r03ff6kz4u4kzd92pjgsfddye7grrlqt9rmmt does not match actual signer"},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+
+			// create a new message
+			msg := `{"type":"VLOCALCHAIN_EXECUTE_TX","address":"` + tc.signerAddress +
+				`","messages":[{"@type":"/cosmos.bank.v1beta1.MsgSend","from_address":"` +
+				tc.fromAddress + `","to_address":"` + tc.toAddress +
+				`","amount":[{"denom":"fresh","amount":"100"}]}]}`
+
+			ret, err = handler.Receive(cctx, msg)
+			if tc.failure != "" {
+				if err == nil {
+					t.Fatalf("expected error %v, not nil with return %v", tc.failure, ret)
+				}
+				if err.Error() != tc.failure {
+					t.Fatalf("expected error %v, not %v", tc.failure, err)
+				}
+				return
+			}
+
+			if err != nil {
+				t.Fatalf("unexpected error: %s", err)
+			}
+			if ret == "" {
+				t.Fatalf("expected non-empty json")
+			}
+			if ret != "[{}]" {
+				t.Fatalf("expected response [{}], not %v", ret)
+			}
+		})
+	}
+}

package/x/vstorage/handler.go

@@ -3,6 +3,7 @@ package vstorage
 import (
 	"fmt"
 
+	sdkioerrors "cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
@@ -11,6 +12,6 @@ import (
 func NewHandler(k Keeper) sdk.Handler {
 	return func(ctx sdk.Context, msg sdk.Msg) (*sdk.Result, error) {
 		errMsg := fmt.Sprintf("Unrecognized vstorage Msg type: %T", msg)
-		return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg)
+		return nil, sdkioerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg)
 	}
 }

package/x/vstorage/keeper/keeper.go

@@ -10,6 +10,7 @@ import (
 	"strconv"
 	"strings"
 
+	sdkmath "cosmossdk.io/math"
 	storetypes "github.com/cosmos/cosmos-sdk/store/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	db "github.com/tendermint/tm-db"
@@ -428,7 +429,7 @@ func (k Keeper) GetNoDataValue() []byte {
 	return types.EncodedNoDataValue
 }
 
-func (k Keeper) getIntValue(ctx sdk.Context, path string) (sdk.Int, error) {
+func (k Keeper) getIntValue(ctx sdk.Context, path string) (sdkmath.Int, error) {
 	indexEntry := k.GetEntry(ctx, path)
 	if !indexEntry.HasValue() {
 		return sdk.NewInt(0), nil
@@ -441,14 +442,14 @@ func (k Keeper) getIntValue(ctx sdk.Context, path string) (sdk.Int, error) {
 	return index, nil
 }
 
-func (k Keeper) GetQueueLength(ctx sdk.Context, queuePath string) (sdk.Int, error) {
+func (k Keeper) GetQueueLength(ctx sdk.Context, queuePath string) (sdkmath.Int, error) {
 	head, err := k.getIntValue(ctx, queuePath+".head")
 	if err != nil {
-		return sdk.NewInt(0), err
+		return sdkmath.NewInt(0), err
 	}
 	tail, err := k.getIntValue(ctx, queuePath+".tail")
 	if err != nil {
-		return sdk.NewInt(0), err
+		return sdkmath.NewInt(0), err
 	}
 	// The tail index is exclusive
 	return tail.Sub(head), nil

package/x/vstorage/keeper/querier.go

@@ -3,6 +3,7 @@ package keeper
 import (
 	abci "github.com/tendermint/tendermint/abci/types"
 
+	sdkioerrors "cosmossdk.io/errors"
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
@@ -20,7 +21,7 @@ const (
 // entry path with no extra data, and returns the path of that vstorage entry.
 func getVstorageEntryPath(urlPathSegments []string) (string, error) {
 	if len(urlPathSegments) != 1 || types.ValidatePath(urlPathSegments[0]) != nil {
-		return "", sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "invalid vstorage entry path")
+		return "", sdkioerrors.Wrap(sdkerrors.ErrInvalidRequest, "invalid vstorage entry path")
 	}
 	return urlPathSegments[0], nil
 }
@@ -51,7 +52,7 @@ func NewQuerier(keeper Keeper, legacyQuerierCdc *codec.LegacyAmino) sdk.Querier
 			}
 			return queryChildren(ctx, entryPath, req, keeper, legacyQuerierCdc)
 		default:
-			return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, "unknown vstorage query path")
+			return nil, sdkioerrors.Wrap(sdkerrors.ErrUnknownRequest, "unknown vstorage query path")
 		}
 	}
 }
@@ -60,12 +61,12 @@ func NewQuerier(keeper Keeper, legacyQuerierCdc *codec.LegacyAmino) sdk.Querier
 func queryData(ctx sdk.Context, path string, req abci.RequestQuery, keeper Keeper, legacyQuerierCdc *codec.LegacyAmino) (res []byte, err error) {
 	entry := keeper.GetEntry(ctx, path)
 	if !entry.HasValue() {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrNotFound, "no data for vstorage path")
+		return nil, sdkioerrors.Wrap(sdkerrors.ErrNotFound, "no data for vstorage path")
 	}
 
 	bz, marshalErr := codec.MarshalJSONIndent(legacyQuerierCdc, types.Data{Value: entry.StringValue()})
 	if marshalErr != nil {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrJSONMarshal, marshalErr.Error())
+		return nil, sdkioerrors.Wrap(sdkerrors.ErrJSONMarshal, marshalErr.Error())
 	}
 
 	return bz, nil
@@ -82,7 +83,7 @@ func queryChildren(ctx sdk.Context, path string, req abci.RequestQuery, keeper K
 
 	bz, err2 := codec.MarshalJSONIndent(legacyQuerierCdc, types.Children{Children: klist})
 	if err2 != nil {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrJSONMarshal, err2.Error())
+		return nil, sdkioerrors.Wrap(sdkerrors.ErrJSONMarshal, err2.Error())
 	}
 
 	return bz, nil

package/x/vstorage/keeper/querier_test.go

@@ -8,6 +8,7 @@ import (
 
 	abci "github.com/tendermint/tendermint/abci/types"
 
+	sdkioerrors "cosmossdk.io/errors"
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
@@ -26,7 +27,7 @@ func TestQuerier(t *testing.T) {
 		label    string
 		path     []string
 		expected []byte
-		err      *sdkerrors.Error
+		err      *sdkioerrors.Error
 	}
 	testCases := []testCase{}
 
@@ -77,7 +78,7 @@ func TestQuerier(t *testing.T) {
 	}...)
 
 	// Ensure stability of cosmos-sdk error codes
-	if codespace, code, _ := sdkerrors.ABCIInfo(sdkerrors.ErrNotFound, true); codespace != "sdk" || code != 38 {
+	if codespace, code, _ := sdkioerrors.ABCIInfo(sdkerrors.ErrNotFound, true); codespace != "sdk" || code != 38 {
 		t.Errorf("cosmos-sdk ErrNotFound has codespace %s, code %d, expected sdk/38", codespace, code)
 	}
 
@@ -102,7 +103,7 @@ func TestQuerier(t *testing.T) {
 		if desc.err != nil {
 			if err == nil {
 				t.Errorf("%s: got no error, want error %q", desc.label, *desc.err)
-			} else if codespace, code, _ := sdkerrors.ABCIInfo(err, true); codespace != desc.err.Codespace() || code != desc.err.ABCICode() {
+			} else if codespace, code, _ := sdkioerrors.ABCIInfo(err, true); codespace != desc.err.Codespace() || code != desc.err.ABCICode() {
 				t.Errorf("%s: got error %v, want error %q", desc.label, err, *desc.err)
 			}
 		} else if !bytes.Equal(res, desc.expected) {

package/proto/agoric/lien/genesis.proto

@@ -1,25 +0,0 @@
-syntax = "proto3";
-package agoric.lien;
-
-import "gogoproto/gogo.proto";
-import "agoric/lien/lien.proto";
-
-option go_package = "github.com/Agoric/agoric-sdk/golang/cosmos/x/lien/types";
-
-// The initial or exported state.
-message GenesisState {
-    option (gogoproto.equal) = false;
-
-    repeated AccountLien liens = 1 [
-        (gogoproto.nullable) = false
-    ];
-}
-
-// The lien on a particular account
-message AccountLien {
-    // Account address, bech32-encoded.
-    string address = 1;
-
-    // The liened amount. Should be nonzero.
-    Lien lien = 2;
-}

package/proto/agoric/lien/lien.proto

@@ -1,25 +0,0 @@
-syntax = "proto3";
-package agoric.lien;
-
-import "gogoproto/gogo.proto";
-import "cosmos/base/v1beta1/coin.proto";
-
-option go_package = "github.com/Agoric/agoric-sdk/golang/cosmos/x/lien/types";
-
-// Lien contains the lien state of a particular account.
-message Lien {
-    // coins holds the amount liened
-    repeated cosmos.base.v1beta1.Coin coins = 1 [
-        (gogoproto.nullable) = false,
-        (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins",
-        (gogoproto.moretags)     = "yaml:\"coins\""
-    ];
-    // delegated tracks the net amount delegated for non-vesting accounts,
-    // or zero coins for vesting accounts.
-    // (Vesting accounts have their own fields to track delegation.)
-    repeated cosmos.base.v1beta1.Coin delegated = 2 [
-        (gogoproto.nullable)     = false,
-        (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins",
-        (gogoproto.moretags)     = "yaml:\"delegated\""
-    ];
-}

package/x/lien/alias.go

@@ -1,17 +0,0 @@
-package lien
-
-import (
-	"github.com/Agoric/agoric-sdk/golang/cosmos/x/lien/keeper"
-	"github.com/Agoric/agoric-sdk/golang/cosmos/x/lien/types"
-)
-
-var (
-	ModuleName              = types.ModuleName
-	NewKeeper               = keeper.NewKeeper
-	NewWrappedAccountKeeper = types.NewWrappedAccountKeeper
-	StoreKey                = types.StoreKey
-)
-
-type (
-	Keeper = keeper.Keeper
-)

package/x/lien/genesis.go

@@ -1,58 +0,0 @@
-package lien
-
-import (
-	"github.com/Agoric/agoric-sdk/golang/cosmos/x/lien/types"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-)
-
-// DefaultGenesisState returns an empty GenesisState.
-func DefaultGenesisState() types.GenesisState {
-	return types.GenesisState{}
-}
-
-// ValidateGenesis returns whether genesisState is well-formed.
-// Since liens can apply to otherwise empty accounts and the source of truth
-// is stored at the Swingset level, we can only validate the addresses.
-func ValidateGenesis(genesisState types.GenesisState) error {
-	for _, accountLien := range genesisState.Liens {
-		_, err := sdk.AccAddressFromBech32(accountLien.Address)
-		if err != nil {
-			return err
-		}
-		err = accountLien.Lien.Coins.Validate()
-		if err != nil {
-			return err
-		}
-		err = accountLien.Lien.Delegated.Validate()
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// InitGenesis uses the genesisState to initialize the store.
-func InitGenesis(ctx sdk.Context, keeper Keeper, genesisState types.GenesisState) {
-	for _, accLien := range genesisState.Liens {
-		addr, err := sdk.AccAddressFromBech32(accLien.GetAddress())
-		if err != nil {
-			panic(err) // not possible if genesis state was validated
-		}
-		lien := accLien.GetLien()
-		keeper.SetLien(ctx, addr, *lien)
-	}
-}
-
-// ExportGenesis reads the store and returns an equivalent GenesisState.
-func ExportGenesis(ctx sdk.Context, keeper Keeper) types.GenesisState {
-	genesisState := types.GenesisState{}
-	keeper.IterateLiens(ctx, func(addr sdk.AccAddress, lien types.Lien) bool {
-		accLien := types.AccountLien{
-			Address: addr.String(),
-			Lien:    &lien,
-		}
-		genesisState.Liens = append(genesisState.Liens, accLien)
-		return false
-	})
-	return genesisState
-}