@agoric/cosmos 0.34.2-dev-f6d77a3.0 → 0.34.2-upgrade-16-dev-8879538.0

package/git-revision.txt

@@ -1 +1 @@
-f6d77a3
+8879538

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/cosmos",
-  "version": "0.34.2-dev-f6d77a3.0+f6d77a3",
+  "version": "0.34.2-upgrade-16-dev-8879538.0+8879538",
   "description": "Connect JS to the Cosmos blockchain SDK",
   "parsers": {
     "js": "mjs"
@@ -39,5 +39,5 @@
   "typeCoverage": {
     "atLeast": 0
   },
-  "gitHead": "f6d77a3516204ba7e1ac7eaac06fab9627032af2"
+  "gitHead": "8879538cd1d125a08346f02dd5701d0d70c90bb8"
 }

package/x/vlocalchain/handler.go

@@ -3,7 +3,6 @@ package vlocalchain
 import (
 	"fmt"
 
-	sdkioerrors "cosmossdk.io/errors"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vlocalchain/keeper"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
@@ -15,7 +14,7 @@ func NewHandler(keeper keeper.Keeper) sdk.Handler {
 		switch msg := msg.(type) {
 		default:
 			errMsg := fmt.Sprintf("Unrecognized vlocalchain Msg type: %T", msg)
-			return nil, sdkioerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg)
+			return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg)
 		}
 	}
 }

package/x/vlocalchain/keeper/keeper_test.go

@@ -1,15 +1,6 @@
 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"
-)
-
+import "testing"
 
 func TestKeeper_ParseRequestTypeURL(t *testing.T) {
 	testCases := []struct {
@@ -39,59 +30,3 @@ func TestKeeper_ParseRequestTypeURL(t *testing.T) {
 		})
 	}
 }
-
-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/vlocalchain.go

@@ -6,6 +6,7 @@ import (
 	"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"
@@ -55,36 +56,28 @@ func (h portHandler) Receive(cctx context.Context, str string) (ret string, err
 			return
 		}
 
-		var errs []error
-		resps := make([]interface{}, len(qms))
+		// 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 {
-				// Only fill out the response if the query was successful.
-				resps[i] = qr
-			} else {
-				errs = append(errs, err) // Accumulate errors
-				resps[i] = &types.QueryResponse{Error: err.Error()}
+			if err != nil {
+				return
 			}
+			if s, err = marshaller.MarshalToString(qr); err != nil {
+				return
+			}
+			resps[i] = []byte(s)
 		}
 
-		bz, err := vm.ProtoJSONMarshalSlice(resps)
-		if err != nil {
-			return "", err
-		}
-
-		switch len(errs) {
-		case 0:
-			err = nil
-		case 1:
-			err = errs[0]
-		case len(resps):
-			err = fmt.Errorf("all queries in batch failed: %v", errs)
-		default:
-			// Let them inspect the individual errors manually.
+		var bz []byte
+		if bz, err = json.Marshal(resps); err != nil {
+			return
 		}
-		return string(bz), err
+		ret = string(bz)
 
 	case "VLOCALCHAIN_EXECUTE_TX":
 		origCtx := sdk.UnwrapSDKContext(cctx)
@@ -104,9 +97,11 @@ func (h portHandler) Receive(cctx context.Context, str string) (ret string, err
 			return
 		}
 
-		// Marshal the responses to proto3 JSON.
-		bz, e := vm.ProtoJSONMarshalSlice(resps)
-		return string(bz), e
+		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)
 	}

package/x/vlocalchain/vlocalchain_test.go

@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"strings"
 	"testing"
-	"time"
 
 	"github.com/Agoric/agoric-sdk/golang/cosmos/app/params"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
@@ -17,7 +16,6 @@ import (
 	storetypes "github.com/cosmos/cosmos-sdk/store/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
-	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 	transfertypes "github.com/cosmos/ibc-go/v6/modules/apps/transfer/types"
 	"github.com/tendermint/tendermint/libs/log"
 
@@ -79,36 +77,8 @@ func (t *mockTransfer) Transfer(cctx context.Context, msg *transfertypes.MsgTran
 	return &transfertypes.MsgTransferResponse{Sequence: 1}, nil
 }
 
-type mockStaking struct {
-	stakingtypes.UnimplementedMsgServer
-	stakingtypes.UnimplementedQueryServer
-}
-
-var _ stakingtypes.MsgServer = (*mockStaking)(nil)
-var _ stakingtypes.QueryServer = (*mockStaking)(nil)
-
-func (s *mockStaking) Undelegate(cctx context.Context, msg *stakingtypes.MsgUndelegate) (*stakingtypes.MsgUndelegateResponse, error) {
-	return &stakingtypes.MsgUndelegateResponse{CompletionTime: time.Now().UTC()}, nil
-}
-
-func (s *mockStaking) UnbondingDelegation(cctx context.Context, req *stakingtypes.QueryUnbondingDelegationRequest) (*stakingtypes.QueryUnbondingDelegationResponse, error) {
-	unbondingDelegation := stakingtypes.UnbondingDelegation{
-		DelegatorAddress: req.DelegatorAddr,
-		ValidatorAddress: "cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj",
-		Entries: []stakingtypes.UnbondingDelegationEntry{
-			{
-				CreationHeight: 100,
-				CompletionTime: time.Now().UTC().Add(time.Hour * 24 * 7),
-				InitialBalance: sdk.NewInt(1000),
-				Balance:        sdk.NewInt(500),
-			},
-		},
-	}
-	return &stakingtypes.QueryUnbondingDelegationResponse{Unbond: unbondingDelegation}, nil
-}
-
 // makeTestKit creates a minimal Keeper and Context for use in testing.
-func makeTestKit(bank *mockBank, transfer *mockTransfer, staking *mockStaking) (vm.PortHandler, context.Context) {
+func makeTestKit(bank *mockBank, transfer *mockTransfer) (vm.PortHandler, context.Context) {
 	encodingConfig := params.MakeEncodingConfig()
 	cdc := encodingConfig.Marshaler
 
@@ -123,10 +93,6 @@ func makeTestKit(bank *mockBank, transfer *mockTransfer, staking *mockStaking) (
 	transfertypes.RegisterInterfaces(encodingConfig.InterfaceRegistry)
 	transfertypes.RegisterMsgServer(txRouter, transfer)
 	transfertypes.RegisterQueryServer(queryRouter, transfer)
-	stakingtypes.RegisterInterfaces(encodingConfig.InterfaceRegistry)
-	stakingtypes.RegisterMsgServer(txRouter, staking)
-	stakingtypes.RegisterQueryServer(queryRouter, staking)
-
 
 	// create a new Keeper
 	keeper := vlocalchain.NewKeeper(cdc, vlocalchainStoreKey, txRouter, queryRouter)
@@ -152,8 +118,7 @@ func makeTestKit(bank *mockBank, transfer *mockTransfer, staking *mockStaking) (
 func TestAllocateAddress(t *testing.T) {
 	bank := &mockBank{}
 	transfer := &mockTransfer{}
-	staking := &mockStaking{}
-	handler, cctx := makeTestKit(bank, transfer, staking)
+	handler, cctx := makeTestKit(bank, transfer)
 
 	addrs := map[string]bool{
 		firstAddr: false,
@@ -196,8 +161,7 @@ func TestQuery(t *testing.T) {
 		alreadyAddr: []sdk.Coin{sdk.NewCoin("stale", sdk.NewInt(321))},
 	}}
 	transfer := &mockTransfer{}
-	staking := &mockStaking{}
-	handler, cctx := makeTestKit(bank, transfer, staking)
+	handler, cctx := makeTestKit(bank, transfer)
 
 	// get balances
 	testCases := []struct {
@@ -266,68 +230,6 @@ func TestQuery(t *testing.T) {
 			}
 		})
 	}
-
-	t.Run("UnbondingDelegation", func(t *testing.T) {
-		// create a new message
-		msg := `{"type":"VLOCALCHAIN_QUERY_MANY","messages":[{"@type":"/cosmos.staking.v1beta1.QueryUnbondingDelegationRequest","delegator_addr":"` + firstAddr + `","validator_addr":"cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj"}]}`
-		t.Logf("query request: %v", msg)
-		ret, err := handler.Receive(cctx, msg)
-		t.Logf("query response: %v", ret)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if ret == "" {
-			t.Fatalf("expected non-empty json")
-		}
-
-		// Unmarshal the JSON response
-		var respJSON []map[string]interface{}
-		if err := json.Unmarshal([]byte(ret), &respJSON); err != nil {
-			t.Fatalf("unexpected error unmarshalling JSON response: %v", err)
-		}
-
-		// Check the response fields
-		if len(respJSON) != 1 {
-			t.Fatalf("expected 1 response, got %d", len(respJSON))
-		}
-		resp := respJSON[0]
-
-		replyAny, ok := resp["reply"].(map[string]interface{})
-		if !ok {
-			t.Fatalf("expected reply field to be a map, got %v", resp["reply"])
-		}
-
-		unbond, ok := replyAny["unbond"].(map[string]interface{})
-		if !ok {
-			t.Fatalf("expected unbond field to be a map, got %v", replyAny["unbond"])
-		}
-
-		// Check the field names and values
-		if unbond["delegatorAddress"] != firstAddr {
-			t.Errorf("expected delegatorAddress %s, got %v", firstAddr, unbond["delegator_address"])
-		}
-		if unbond["validatorAddress"] != "cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj" {
-			t.Errorf("expected validatorAddress cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj, got %v", unbond["validator_address"])
-		}
-
-		entries, ok := unbond["entries"].([]interface{})
-		if !ok || len(entries) != 1 {
-			t.Fatalf("expected 1 unbonding delegation entry, got %v", entries)
-		}
-		entry, ok := entries[0].(map[string]interface{})
-		if !ok {
-			t.Fatalf("expected unbonding delegation entry to be a map, got %v", entries[0])
-		}
-		if entry["creationHeight"] != "100" {
-			t.Errorf("expected creationHeight \"100\", got %v", entry["creation_height"])
-		}
-		if entry["balance"] != "500" {
-			t.Errorf("expected balance \"500\", got %v", entry["balance"])
-		}
-		if _, ok := entry["completionTime"]; !ok {
-			t.Error("expected completionTime field in the response")
-		}
-	})
 }
 
 func TestExecuteTx(t *testing.T) {
@@ -337,8 +239,7 @@ func TestExecuteTx(t *testing.T) {
 		alreadyAddr: []sdk.Coin{sdk.NewCoin("stale", sdk.NewInt(321))},
 	}}
 	transfer := &mockTransfer{}
-	staking := &mockStaking{}
-	handler, cctx := makeTestKit(bank, transfer, staking)
+	handler, cctx := makeTestKit(bank, transfer)
 
 	// create a new message
 	msg := `{"type":"VLOCALCHAIN_ALLOCATE_ADDRESS"}`
@@ -401,34 +302,4 @@ func TestExecuteTx(t *testing.T) {
 			}
 		})
 	}
-
-	t.Run("MsgUndelegate", func(t *testing.T) {
-		// create a new message
-		msg := `{"type":"VLOCALCHAIN_EXECUTE_TX","address":"` + addr +
-			`","messages":[{"@type":"/cosmos.staking.v1beta1.MsgUndelegate","delegatorAddress":"` +
-			addr + `","validatorAddress":"cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj","amount":{"denom":"stake","amount":"100"}}]}`
-
-		ret, err := handler.Receive(cctx, msg)
-		if err != nil {
-			t.Fatalf("unexpected error: %s", err)
-		}
-		if ret == "" {
-			t.Fatalf("expected non-empty json")
-		}
-
-		// Unmarshal the response
-		var resp []map[string]interface{}
-		if err := json.Unmarshal([]byte(ret), &resp); err != nil {
-			t.Fatalf("unexpected error unmarshalling response: %v", err)
-		}
-
-		// Check the response fields
-		if len(resp) != 1 {
-			t.Fatalf("expected 1 response, got %d", len(resp))
-		}
-		
-		if _, ok := resp[0]["completionTime"]; !ok {
-			t.Error("expected 'completionTime' field in response")
-		}
-	})
 }

package/vm/proto_json.go

@@ -1,38 +0,0 @@
-package vm
-
-import (
-	"encoding/json"
-
-	"github.com/gogo/protobuf/jsonpb"
-	"github.com/gogo/protobuf/proto"
-)
-
-// We need jsonpb for its access to the global registry.
-var marshaller = jsonpb.Marshaler{EmitDefaults: true}
-
-func ProtoJSONMarshal(val interface{}) ([]byte, error) {
-	if pm, ok := val.(proto.Message); ok {
-		var s string
-		s, err := marshaller.MarshalToString(pm)
-		return []byte(s), err
-	}
-
-	// Marshal a non-proto value to JSON.
-	return json.Marshal(val)
-}
-
-// ProtoJSONMarshalSlice marshals a slice of proto messages and non-proto values to
-// a single JSON byte slice.
-func ProtoJSONMarshalSlice(vals []interface{}) ([]byte, error) {
-	var err error
-	jsonSlice := make([]json.RawMessage, len(vals))
-	for i, val := range vals {
-		jsonSlice[i], err = ProtoJSONMarshal(val)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	// Marshal the JSON array to a single JSON byte slice.
-	return json.Marshal(jsonSlice)
-}

package/vm/proto_json_test.go

@@ -1,103 +0,0 @@
-package vm_test
-
-import (
-	"bytes"
-	"strings"
-	"testing"
-
-	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
-
-	sdk "github.com/cosmos/cosmos-sdk/types"
-
-	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
-	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
-)
-
-func TestProtoJSONMarshal(t *testing.T) {
-	accAddr, err := sdk.AccAddressFromHexUnsafe("0123456789")
-	if err != nil {
-		panic(err)
-	}
-	valAddr, err := sdk.ValAddressFromHex("9876543210")
-	if err != nil {
-		panic(err)
-	}
-	coin := sdk.NewInt64Coin("uatom", 1234567)
-
-	testCases := []struct {
-		name     string
-		create   func() interface{}
-		expected string
-	}{
-		{
-			"nil",
-			func() interface{} {
-				return nil
-			},
-			`null`,
-		},
-		{
-			"primitive number",
-			func() interface{} {
-				return 12345
-			},
-			`12345`,
-		},
-		{
-			"MsgDelegate",
-			func() interface{} {
-				return stakingtypes.NewMsgDelegate(accAddr, valAddr, coin)
-			},
-			`{"delegatorAddress":"cosmos1qy352eufjjmc9c","validatorAddress":"cosmosvaloper1npm9gvss52mlmk","amount":{"denom":"uatom","amount":"1234567"}}`,
-		},
-		{
-			"QueryDenomOwnersResponse",
-			func() interface{} {
-				return &banktypes.QueryDenomOwnersResponse{
-					DenomOwners: []*banktypes.DenomOwner{
-						{
-							Address: accAddr.String(),
-							Balance: coin,
-						},
-						{
-							Address: valAddr.String(),
-							Balance: coin.Add(coin),
-						},
-					},
-				}
-			},
-			`{"denomOwners":[{"address":"cosmos1qy352eufjjmc9c","balance":{"denom":"uatom","amount":"1234567"}},{"address":"cosmosvaloper1npm9gvss52mlmk","balance":{"denom":"uatom","amount":"2469134"}}],"pagination":null}`,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			val := tc.create()
-			bz, err := vm.ProtoJSONMarshal(val)
-			if err != nil {
-				t.Errorf("ProtoJSONMarshal of %q failed %v", val, err)
-			}
-			if !bytes.Equal(bz, []byte(tc.expected)) {
-				t.Errorf("ProtoJSONMarshal of %q returned %q, expected %q", val, string(bz), tc.expected)
-			}
-		})
-	}
-
-	t.Run("all in a slice", func(t *testing.T) {
-		vals := make([]interface{}, len(testCases))
-		expectedJson := make([]string, len(testCases))
-		for i, tc := range testCases {
-			vals[i] = tc.create()
-			expectedJson[i] = tc.expected
-		}
-		bz, err := vm.ProtoJSONMarshalSlice(vals)
-		if err != nil {
-			t.Errorf("ProtoJSONMarshalSlice of %q failed %v", vals, err)
-		}
-
-		expected := "[" + strings.Join(expectedJson, ",") + "]"
-		if !bytes.Equal(bz, []byte(expected)) {
-			t.Errorf("ProtoJSONMarshalSlice of %q returned %q, expected %q", vals, string(bz), expected)
-		}
-	})
-}