@agoric/cosmos 0.35.0-upgrade-14-dev-c8f9e7b.0 → 0.35.0-upgrade-16a-dev-fb592e4.0

package/x/vlocalchain/keeper/keeper.go

@@ -0,0 +1,279 @@
+package keeper
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"reflect"
+	"strings"
+	"unicode"
+
+	"github.com/gogo/protobuf/jsonpb"
+	"github.com/gogo/protobuf/proto"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	storetypes "github.com/cosmos/cosmos-sdk/store/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkaddress "github.com/cosmos/cosmos-sdk/types/address"
+
+	abci "github.com/tendermint/tendermint/abci/types"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vlocalchain/types"
+)
+
+// Keeper maintains the link to data storage and exposes getter/setter methods for the various parts of the state machine
+type Keeper struct {
+	key         storetypes.StoreKey
+	cdc         codec.Codec
+	msgRouter   types.MsgRouter
+	queryRouter types.GRPCQueryRouter
+}
+
+// NewKeeper creates a new dIBC Keeper instance
+func NewKeeper(
+	cdc codec.Codec,
+	key storetypes.StoreKey,
+	msgRouter types.MsgRouter,
+	queryRouter types.GRPCQueryRouter,
+) Keeper {
+	return Keeper{
+		key:         key,
+		cdc:         cdc,
+		msgRouter:   msgRouter,
+		queryRouter: queryRouter,
+	}
+}
+
+// DeserializeRequests uses the global proto codec's proto3 JSON
+// unmarshaller and then unpacks the Any types into actual objects.
+func (k Keeper) DeserializeRequests(bz []byte) ([]types.QueryRequest, error) {
+	var cosmosTx types.CosmosTx
+	unmarshaler := &jsonpb.Unmarshaler{}
+
+	// Convert the bz byte slice to an io.Reader
+	rdr := bytes.NewReader(bz)
+	if err := unmarshaler.Unmarshal(rdr, &cosmosTx); err != nil {
+		return nil, err
+	}
+
+	msgs := make([]types.QueryRequest, len(cosmosTx.Messages))
+	for i, anyMsg := range cosmosTx.Messages {
+		// TODO: Generalize using proto service reflection.
+		fullMethod, responseURL := parseRequestTypeURL(anyMsg.TypeUrl)
+		msgs[i] = types.QueryRequest{
+			FullMethod: fullMethod,
+			ReplyType:  responseURL,
+			Request:    anyMsg,
+		}
+	}
+	return msgs, nil
+}
+
+const (
+	requestSuffix  = "Request"
+	responseSuffix = "Response"
+)
+
+// parseRequestTypeURL returns the full method and response type URL
+//
+// This is a hack that only works if the names are conventionally
+// abc.def.1beta1.QueryFooBarRequest
+// abc.def.1beta1.Query/FooBar
+// abc.def.1beta1.QueryFooBarResponse
+func parseRequestTypeURL(typeURL string) (string, string) {
+	typePrefix := strings.TrimSuffix(typeURL, requestSuffix)
+	responseURL := typePrefix + responseSuffix
+
+	ifacePos := strings.LastIndex(typePrefix, ".") + 1
+	iface := typePrefix[ifacePos:]
+
+	// Find the second uppercase letter.
+	first := true
+	serviceEnd := strings.IndexFunc(iface, func(r rune) bool {
+		if first {
+			first = false
+			return false
+		}
+		return unicode.IsUpper(r)
+	})
+
+	var fullMethod string
+	serviceEnd += ifacePos
+	if serviceEnd < 0 {
+		fullMethod = typePrefix[0:ifacePos] + "/" + iface
+	} else {
+		fullMethod = typePrefix[0:serviceEnd] + "/" + typePrefix[serviceEnd:]
+	}
+	return fullMethod, responseURL
+}
+
+func (k Keeper) ResolveProtoMessage(typeUrl string) (proto.Message, error) {
+	unprefixed := strings.TrimPrefix(typeUrl, "/")
+	msgPointerType := proto.MessageType(unprefixed)
+	if msgPointerType == nil {
+		return nil, fmt.Errorf("unable to resolve type URL %s", typeUrl)
+	}
+	newMsg := reflect.New(msgPointerType.Elem())
+	target, ok := newMsg.Interface().(proto.Message)
+	if !ok {
+		return nil, fmt.Errorf("unable to cast %s to proto.Message", typeUrl)
+	}
+	return target, nil
+}
+
+func (k Keeper) Query(cctx context.Context, qm types.QueryRequest) (*types.QueryResponse, error) {
+	// We currently only handle a few kinds of requests.
+	handler := k.queryRouter.Route(qm.FullMethod)
+	if handler == nil {
+		return nil, fmt.Errorf("unrecognized query route for method %s", qm.FullMethod)
+	}
+
+	ctx := sdk.UnwrapSDKContext(cctx)
+	req := abci.RequestQuery{
+		Data:   qm.Request.Value,
+		Height: ctx.BlockHeight(),
+	}
+
+	abcires, err := handler(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	res := types.QueryResponse{
+		Height: abcires.Height,
+	}
+
+	if abcires.IsOK() {
+		// Wrap the reply in an Any.
+		res.Reply = &codectypes.Any{TypeUrl: qm.ReplyType, Value: abcires.Value}
+	} else {
+		res.Error = abcires.Info
+	}
+
+	return &res, nil
+}
+
+func (k Keeper) DeserializeTxMessages(bz []byte) ([]sdk.Msg, error) {
+	var cosmosTx types.CosmosTx
+	if err := k.cdc.UnmarshalJSON(bz, &cosmosTx); err != nil {
+		return nil, err
+	}
+	msgs := make([]sdk.Msg, len(cosmosTx.Messages))
+	for i, anyMsg := range cosmosTx.Messages {
+		err := k.cdc.UnpackAny(anyMsg, &msgs[i])
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return msgs, nil
+}
+
+type HasValidateBasic interface {
+	ValidateBasic() error
+}
+
+func (k Keeper) authenticateTx(msgs []sdk.Msg, actualSigner string) error {
+	for _, msg := range msgs {
+		// Validate that all required signers are satisfied (i.e. they match the actual signer).
+		for _, requiredSignerAddress := range msg.GetSigners() {
+			requiredSigner := requiredSignerAddress.String()
+			if requiredSigner != actualSigner {
+				err := fmt.Errorf("required signer %s does not match actual signer", requiredSigner)
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (k Keeper) ExecuteTx(origCtx sdk.Context, addr string, msgs []sdk.Msg) ([]interface{}, error) {
+	// Do any preliminary basic stateless validation.
+	for _, msg := range msgs {
+		if m, ok := msg.(HasValidateBasic); ok {
+			if err := m.ValidateBasic(); err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	if err := k.authenticateTx(msgs, addr); err != nil {
+		return nil, err
+	}
+
+	resps := make([]interface{}, len(msgs))
+
+	// CacheContext returns a new context with the multi-store branched into a cached storage object
+	// writeCache is called only if all msgs succeed, performing state transitions atomically
+	cacheCtx, writeCache := origCtx.CacheContext()
+
+	for i, msg := range msgs {
+		protoAny, err := k.executeMsg(cacheCtx, msg)
+		if err != nil {
+			return nil, err
+		}
+
+		if err = k.cdc.UnpackAny(protoAny, &resps[i]); err != nil {
+			return nil, err
+		}
+	}
+
+	// NOTE: The context returned by CacheContext() creates a new EventManager, so events must be correctly propagated back to the current context
+	origCtx.EventManager().EmitEvents(cacheCtx.EventManager().Events())
+	writeCache()
+
+	return resps, nil
+}
+
+// Attempts to get the message handler from the router and if found will then execute the message.
+// If the message execution is successful, the proto marshaled message response will be returned.
+func (k Keeper) executeMsg(ctx sdk.Context, msg sdk.Msg) (*codectypes.Any, error) {
+	handler := k.msgRouter.Handler(msg)
+	if handler == nil {
+		return nil, fmt.Errorf("invalid message route for msg %s", sdk.MsgTypeURL(msg))
+	}
+
+	res, err := handler(ctx, msg)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(res.MsgResponses) != 1 {
+		panic(fmt.Errorf("expected 1 MsgResponse, got %d", len(res.MsgResponses)))
+	}
+
+	// NOTE: The sdk msg handler creates a new EventManager, so events must be correctly propagated back to the current context
+	ctx.EventManager().EmitEvents(res.GetEvents())
+
+	// Each individual sdk.Result has exactly one Msg response. We aggregate here.
+	msgResponse := res.MsgResponses[0]
+	if msgResponse == nil {
+		return nil, fmt.Errorf("got nil Msg response for msg %s", sdk.MsgTypeURL(msg))
+	}
+
+	return msgResponse, nil
+}
+
+// AllocateAddress returns an sdk.AccAddress derived using a host module account
+// address, sequence number, the current block app hash, and the current block
+// data hash.  The sdk.AccAddress returned is a sub-address of the host module
+// account.
+func (k Keeper) AllocateAddress(cctx context.Context) sdk.AccAddress {
+	ctx := sdk.UnwrapSDKContext(cctx)
+	store := ctx.KVStore(k.key)
+
+	localchainModuleAcc := sdkaddress.Module(types.ModuleName, []byte("localchain"))
+	header := ctx.BlockHeader()
+
+	// Increment our sequence number.
+	seq := store.Get(types.KeyLastSequence)
+	seq = types.NextSequence(seq)
+	store.Set(types.KeyLastSequence, seq)
+
+	buf := seq
+	buf = append(buf, header.AppHash...)
+	buf = append(buf, header.DataHash...)
+
+	return sdkaddress.Derive(localchainModuleAcc, buf)
+}

package/x/vlocalchain/keeper/keeper_test.go

@@ -0,0 +1,97 @@
+package keeper
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/app/params"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+)
+
+
+func TestKeeper_ParseRequestTypeURL(t *testing.T) {
+	testCases := []struct {
+		name        string
+		typeUrl     string
+		fullMethod  string
+		responseURL string
+	}{
+		{"valid Request", "abc.def.1beta1.QueryFooBarRequest", "abc.def.1beta1.Query/FooBar", "abc.def.1beta1.QueryFooBarResponse"},
+		{"not Request", "abc.def.1beta1.QueryFooBar", "abc.def.1beta1.Query/FooBar", "abc.def.1beta1.QueryFooBarResponse"},
+		{"valid Msg", "cosmos.bank.v1beta1.MsgSend", "cosmos.bank.v1beta1.Msg/Send", "cosmos.bank.v1beta1.MsgSendResponse"},
+		{"GIGO", "helloWorld", "hello/World", "helloWorldResponse"},
+		{"one message", "Hello", "/Hello", "HelloResponse"},
+		{"one namespace", "world", "/world", "worldResponse"},
+		{"empty", "", "/", "Response"},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			fullMethod, responseURL := parseRequestTypeURL(tc.typeUrl)
+			if fullMethod != tc.fullMethod {
+				t.Errorf("%v fullMethod expected %v, got %v", tc.typeUrl, tc.fullMethod, fullMethod)
+			}
+			if responseURL != tc.responseURL {
+				t.Errorf("%v response expected %v, got %v", tc.typeUrl, tc.responseURL, responseURL)
+			}
+		})
+	}
+}
+
+func TestKeeper_DeserializeTxMessages(t *testing.T) {
+	encodingConfig := params.MakeEncodingConfig()
+	cdc := encodingConfig.Marshaler
+
+	banktypes.RegisterInterfaces(encodingConfig.InterfaceRegistry)
+
+	keeper := NewKeeper(cdc, nil, nil, nil)
+
+	expectedMsgSend := []sdk.Msg{
+		&banktypes.MsgSend{
+			FromAddress: "cosmos1abc",
+			ToAddress:   "cosmos1xyz",
+			Amount:      sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100))),
+		},
+	}
+
+	testCases := []struct {
+		name     string
+		json     string
+		expected []sdk.Msg
+		wantErr  bool
+	}{
+		{
+			name: "camelCase keys",
+			json: `{"messages":[{"@type":"/cosmos.bank.v1beta1.MsgSend","fromAddress":"cosmos1abc","toAddress":"cosmos1xyz","amount":[{"denom":"stake","amount":"100"}]}]}`,
+			expected: expectedMsgSend,
+			wantErr: false,
+		},
+		{
+			name: "snake_case keys",
+			json: `{"messages":[{"@type":"/cosmos.bank.v1beta1.MsgSend","from_address":"cosmos1abc","to_address":"cosmos1xyz","amount":[{"denom":"stake","amount":"100"}]}]}`,
+			expected: expectedMsgSend,
+			wantErr: false,
+		},
+		{
+			name: "misspelled key",
+			json: `{"messages":[{"@type":"/cosmos.bank.v1beta1.MsgSend","from_addresss":"cosmos1abc","to_address":"cosmos1xyz","amount":[{"denom":"stake","amount":"100"}]}]}`,
+			expected: expectedMsgSend,
+			wantErr: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			msgs, err := keeper.DeserializeTxMessages([]byte(tc.json))
+
+			if tc.wantErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tc.expected, msgs)
+			}
+		})
+	}
+}

package/x/vlocalchain/types/codec.go

@@ -0,0 +1,34 @@
+package types
+
+import (
+	"github.com/cosmos/cosmos-sdk/codec"
+	cdctypes "github.com/cosmos/cosmos-sdk/codec/types"
+	cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+var (
+	amino = codec.NewLegacyAmino()
+
+	// ModuleCdc references the global x/deployment module codec. Note, the codec should
+	// ONLY be used in certain instances of tests and for JSON encoding as Amino is
+	// still used for that purpose.
+	//
+	// The actual codec used for serialization should be provided to x/swingset and
+	// defined at the application level.
+	ModuleCdc = codec.NewProtoCodec(cdctypes.NewInterfaceRegistry())
+)
+
+func init() {
+	RegisterCodec(amino)
+	cryptocodec.RegisterCrypto(amino)
+	amino.Seal()
+}
+
+// RegisterCodec registers concrete types on the Amino codec
+func RegisterCodec(cdc *codec.LegacyAmino) {}
+
+// RegisterInterfaces registers the x/swingset interfaces types with the interface registry
+func RegisterInterfaces(registry cdctypes.InterfaceRegistry) {
+	registry.RegisterImplementations((*sdk.Msg)(nil))
+}

package/x/vlocalchain/types/key.go

@@ -0,0 +1,27 @@
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+const (
+	// module name
+	ModuleName = "vlocalchain"
+
+	// StoreKey to be used when creating the KVStore
+	StoreKey = ModuleName
+)
+
+var (
+	// KeyLastSequence is the key used to store the last sequence (big-endian
+	// uint64) to help derive a fresh module account address
+	KeyLastSequence = []byte("lastSequence")
+)
+
+// NextSequence interprets the value byte slice as a big-endian uint64, and
+// returns a new big-endian byte slice representing the value plus 1.
+func NextSequence(value []byte) []byte {
+	lastSequence := sdk.BigEndianToUint64(value)
+	lastSequence += 1
+	return sdk.Uint64ToBigEndian(lastSequence)
+}

package/x/vlocalchain/types/msgs.go

@@ -0,0 +1,16 @@
+package types
+
+import (
+	"github.com/cosmos/cosmos-sdk/baseapp"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+const RouterKey = ModuleName // this was defined in your key.go file
+
+type MsgRouter interface {
+	Handler(msg sdk.Msg) func(ctx sdk.Context, msg sdk.Msg) (*sdk.Result, error)
+}
+
+type GRPCQueryRouter interface {
+	Route(path string) baseapp.GRPCQueryHandler
+}