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

package/vm/jsonrpcconn/jsonrpcconn.go

@@ -0,0 +1,160 @@
+/*
+Package jsonrpcconn provides a way to multiplex an io stream into two
+streams where incoming JSON-RPC requests go to one stream and incoming
+JSON-RPC responses go to another. Outputs are merged.
+
+The JSON-RPCv1 protocol is peer-to-peer, but the implementation in the Go
+standard library only supports client-server. By multiplexing a single
+io.ReadWriteCloser stream into separate server (receives requests) and
+client (receives responses) streams, two RPC halves can share the same
+underlying connection.
+*/
+package jsonrpcconn
+
+import (
+	"encoding/json"
+	"io"
+)
+
+// jsonRpcMsg can unmarshal either a JSON-RPC
+// request or response object.
+type jsonRpcMsg struct {
+	Error  json.RawMessage   `json:"error"`
+	Id     json.RawMessage   `json:"id"`
+	Method *string           `json:"method"`
+	Params []json.RawMessage `json:"params"`
+	Result json.RawMessage   `json:"result"`
+}
+
+// mux holds the underlying connection and the pipe reader/writer
+// pairs for the server (request) and client (response) sides.
+// Any protocol error or closing any channel will cause shutdown.
+type mux struct {
+	conn       io.ReadWriteCloser
+	reqReader  *io.PipeReader
+	reqWriter  *io.PipeWriter
+	respReader *io.PipeReader
+	respWriter *io.PipeWriter
+}
+
+func newMux(conn io.ReadWriteCloser) mux {
+	reqReader, reqWriter := io.Pipe()
+	respReader, respWriter := io.Pipe()
+	m := mux{
+		conn:       conn,
+		reqReader:  reqReader,
+		reqWriter:  reqWriter,
+		respReader: respReader,
+		respWriter: respWriter,
+	}
+	go m.input()
+	return m
+}
+
+func (m mux) input() {
+	var err error
+	dec := json.NewDecoder(m.conn)
+	for {
+		// read the next JSON value, preserve its wire format
+		var raw json.RawMessage
+		err = dec.Decode(&raw)
+		if err != nil {
+			break
+		}
+
+		// parse as JSON-RPC
+		var msg jsonRpcMsg
+		err = json.Unmarshal(raw, &msg)
+		if err != nil {
+			break
+		}
+
+		// send to one of the outputs
+		if msg.Method != nil {
+			// presume a request, the consumer will handle any missing fields
+			_, err = m.reqWriter.Write(raw)
+		} else {
+			// presume a response, the consumer will handle any missing fields
+			_, err = m.respWriter.Write(raw)
+		}
+		if err != nil {
+			break
+		}
+	}
+	m.reqWriter.CloseWithError(err)
+	m.respWriter.CloseWithError(err)
+	m.conn.Close()
+}
+
+// clientChan is a view of the mux for the client channel.
+type clientChan mux
+
+// Close implements the io.Closer interface.
+func (c clientChan) Close() error {
+	return c.conn.Close()
+}
+
+// Read implements the io.Reader interface.
+func (c clientChan) Read(p []byte) (int, error) {
+	return c.respReader.Read(p)
+}
+
+// Write implements the io.Writer interface.
+func (c clientChan) Write(p []byte) (int, error) {
+	return c.conn.Write(p)
+}
+
+// serverChan is a view of the mux for the server channel.
+type serverChan mux
+
+// Close implements the io.Closer interface.
+func (s serverChan) Close() error {
+	return s.conn.Close()
+}
+
+// Read implements the io.Reader interface.
+func (s serverChan) Read(p []byte) (int, error) {
+	return s.reqReader.Read(p)
+}
+
+// Write implements the io.Writer interface.
+func (s serverChan) Write(p []byte) (int, error) {
+	return s.conn.Write(p)
+}
+
+// ClientServerConn multiplexes an input/output stream for the JSON-RPCv1
+// protocol into streams specific for client traffic and server traffic.
+// Full JSON objects must be written atomically to either stream to
+// interleave correctly.
+func ClientServerConn(conn io.ReadWriteCloser) (clientConn io.ReadWriteCloser, serverConn io.ReadWriteCloser) {
+	m := newMux(conn)
+	clientConn = clientChan(m)
+	serverConn = serverChan(m)
+	return
+}
+
+type conn struct {
+	rd io.ReadCloser
+	wr io.WriteCloser
+}
+
+// Close implments the io.Closer interface.
+func (e conn) Close() error {
+	e.rd.Close()
+	return e.wr.Close()
+}
+
+// Read implements the io.Reader interface.
+func (e conn) Read(p []byte) (int, error) {
+	return e.rd.Read(p)
+}
+
+// Write implements the io.Writer interface.
+func (e conn) Write(p []byte) (int, error) {
+	return e.wr.Write(p)
+}
+
+// NewConn returns a connection from a reader and a writer.
+func NewConn(rd io.ReadCloser, wr io.WriteCloser) io.ReadWriteCloser {
+	return conn{rd: rd, wr: wr}
+}

package/vm/jsonrpcconn/jsonrpcconn_test.go

@@ -0,0 +1,126 @@
+package jsonrpcconn_test
+
+import (
+	"fmt"
+	"net"
+	"net/rpc"
+	"net/rpc/jsonrpc"
+	"testing"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm/jsonrpcconn"
+)
+
+/*
+type testConn struct {
+	input  *bytes.Buffer
+	output *bytes.Buffer
+	done   chan struct{}
+}
+
+func newTestConn(input string) io.ReadWriteCloser {
+	return testConn{
+		input:  bytes.NewBufferString(input),
+		output: new(bytes.Buffer),
+		done:   make(chan struct{}),
+	}
+}
+
+func (tc testConn) Read(p []byte) (int, error) {
+	n, err := tc.input.Read(p)
+	if err == io.EOF {
+		<-tc.done
+	}
+	return n, err
+}
+
+func (tc testConn) Write(p []byte) (int, error) {
+	return tc.output.Write(p)
+}
+
+func (tc testConn) Close() error {
+	close(tc.done)
+	return nil
+}
+
+func TestMux(t *testing.T) {
+	input := `{"id": 1, "method": "foo", "params": [1, 2]}
+	{"id": "aaa", "result": true, "error": null}
+	{"id": null, "method": "bar", "params": ["string", 3, false]}`
+	tc := newTestConn(input)
+	client, server := jsonrpcconn.ClientServerConn(tc)
+	client.Read
+	var wg sync.WaitGroup
+	wg.Add(2)
+	go func() {
+
+	}()
+	wg.Wait()
+} */
+
+type Args struct {
+	A, B int
+}
+
+type Arith struct{}
+
+func (a *Arith) Add(args Args, reply *int) error {
+	*reply = args.A + args.B
+	return nil
+}
+
+func (a *Arith) Mul(args Args, reply *int) error {
+	*reply = args.A * args.B
+	return nil
+}
+
+func (a *Arith) Oops(args Args, reply *int) error {
+	return fmt.Errorf("oops")
+}
+
+func TestJsonRPC(t *testing.T) {
+	left, right := net.Pipe()
+	leftClientConn, leftServerConn := jsonrpcconn.ClientServerConn(left)
+	rightClientConn, rightServerConn := jsonrpcconn.ClientServerConn(right)
+
+	leftClient := jsonrpc.NewClient(leftClientConn)
+	leftServer := rpc.NewServer()
+	err := leftServer.RegisterName("foo", new(Arith))
+	if err != nil {
+		t.Fatal(err)
+	}
+	go leftServer.ServeCodec(jsonrpc.NewServerCodec(leftServerConn))
+
+	rightClient := jsonrpc.NewClient(rightClientConn)
+	rightServer := rpc.NewServer()
+	err = rightServer.RegisterName("bar", new(Arith))
+	if err != nil {
+		t.Fatal(err)
+	}
+	go rightServer.ServeCodec(jsonrpc.NewServerCodec(rightServerConn))
+
+	var reply int
+	err = leftClient.Call("bar.Add", Args{1, 2}, &reply)
+	if err != nil {
+		t.Error(err)
+	}
+	if reply != 3 {
+		t.Errorf("bar.Add want 3, got %d", reply)
+	}
+
+	err = rightClient.Call("foo.Mul", Args{2, 3}, &reply)
+	if err != nil {
+		t.Error(err)
+	}
+	if reply != 6 {
+		t.Errorf("foo.Mul want 6, got %d", reply)
+	}
+
+	err = leftClient.Call("bar.Oops", Args{7, 11}, &reply)
+	if err == nil {
+		t.Errorf("bar.Oops want error, got reply %d", reply)
+	} else if err.Error() != "oops" {
+		t.Errorf(`bar.Oops want error "oops", got "%s"`, err.Error())
+	}
+	leftClient.Close()
+	rightClient.Close()
+}

package/vm/proto_json.go

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,103 @@
+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)
+		}
+	})
+}

package/vm/server.go

@@ -0,0 +1,124 @@
+package vm
+
+import (
+	"context"
+	"fmt"
+	"sync"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// AgdServer manages communication from the VM to the ABCI app.  The structure
+// is mutable and the mutex must be held to read or write any field.
+type AgdServer struct {
+	currentCtx context.Context
+	mtx        sync.Mutex
+	// zero is an out-of-bounds port number
+	lastPort int
+	// portToHandler[i] is nonzero iff portToName[i] is nonempty
+	portToHandler map[int]PortHandler
+	// portToName[nameToPort[s]] == s && nameToPort[portToName[i]] == i for all i, s
+	portToName map[int]string
+	nameToPort map[string]int
+}
+
+var wrappedEmptySDKContext = sdk.WrapSDKContext(
+	sdk.Context{}.WithContext(context.Background()),
+)
+
+// NewAgdServer returns a pointer to a new AgdServer with empty context and port
+// mappings.
+func NewAgdServer() *AgdServer {
+	return &AgdServer{
+		currentCtx:    wrappedEmptySDKContext,
+		mtx:           sync.Mutex{},
+		portToHandler: make(map[int]PortHandler),
+		portToName:    make(map[int]string),
+		nameToPort:    make(map[string]int),
+	}
+}
+
+// SetControllerContext sets the context to the given argument and returns a function
+// which will reset the context to an empty context (not the old context).
+func (s *AgdServer) SetControllerContext(ctx sdk.Context) func() {
+	// We are only called by the controller, so we assume that it is billing its
+	// own meter usage.
+	s.mtx.Lock()
+	defer s.mtx.Unlock()
+	s.currentCtx = sdk.WrapSDKContext(ctx.WithGasMeter(sdk.NewInfiniteGasMeter()))
+	return func() {
+		s.mtx.Lock()
+		defer s.mtx.Unlock()
+		s.currentCtx = wrappedEmptySDKContext
+	}
+}
+
+// getContextAndHandler returns the current context and the handler for the
+// given port number.
+func (s *AgdServer) getContextAndHandler(port int) (context.Context, PortHandler) {
+	s.mtx.Lock()
+	defer s.mtx.Unlock()
+	ctx := s.currentCtx
+	handler := s.portToHandler[port]
+	return ctx, handler
+}
+
+// ReceiveMessage is the method the VM calls in order to have agd receive a
+// Message.
+func (s *AgdServer) ReceiveMessage(msg *Message, reply *string) error {
+	ctx, handler := s.getContextAndHandler(msg.Port)
+	if handler == nil {
+		return fmt.Errorf("unregistered port %d", msg.Port)
+	}
+	resp, err := handler.Receive(ctx, msg.Data)
+	*reply = resp
+	return err
+}
+
+// GetPort returns the port number for the given port name, or 0 if the name is
+// not registered.
+func (s *AgdServer) GetPort(name string) int {
+	s.mtx.Lock()
+	defer s.mtx.Unlock()
+	return s.nameToPort[name]
+}
+
+// MustRegisterPortHandler attempts to RegisterPortHandler, panicing on error.
+func (s *AgdServer) MustRegisterPortHandler(name string, portHandler PortHandler) int {
+	port, err := s.RegisterPortHandler(name, portHandler)
+	if err != nil {
+		panic(err)
+	}
+	return port
+}
+
+// RegisterPortHandler registers the handler to a new port number, then maps the name to it,
+// returning the port number. If the name was previously in use, an error is returned.
+func (s *AgdServer) RegisterPortHandler(name string, portHandler PortHandler) (int, error) {
+	s.mtx.Lock()
+	defer s.mtx.Unlock()
+	if _, ok := s.nameToPort[name]; ok {
+		return 0, fmt.Errorf("name %s already in use", name)
+	}
+	s.lastPort++
+	s.portToHandler[s.lastPort] = NewProtectedPortHandler(portHandler)
+	s.portToName[s.lastPort] = name
+	s.nameToPort[name] = s.lastPort
+	return s.lastPort, nil
+}
+
+// UnregisterPortHandler unregisters the handler and name mappings for this port
+// number, and the reverse mapping for its name, if any of these exist.  If
+// portNum is not registered, return an error.
+func (s *AgdServer) UnregisterPortHandler(portNum int) error {
+	s.mtx.Lock()
+	defer s.mtx.Unlock()
+	if s.portToHandler[portNum] == nil {
+		return fmt.Errorf("port %d not registered", portNum)
+	}
+	delete(s.portToHandler, portNum)
+	name := s.portToName[portNum]
+	delete(s.portToName, portNum)
+	delete(s.nameToPort, name)
+	return nil
+}

package/x/swingset/abci.go

@@ -15,27 +15,27 @@ import (
 )
 
 type beginBlockAction struct {
-	vm.ActionHeader `actionType:"BEGIN_BLOCK"`
-	ChainID         string       `json:"chainID"`
-	Params          types.Params `json:"params"`
+	*vm.ActionHeader `actionType:"BEGIN_BLOCK"`
+	ChainID          string       `json:"chainID"`
+	Params           types.Params `json:"params"`
 }
 
 type endBlockAction struct {
-	vm.ActionHeader `actionType:"END_BLOCK"`
+	*vm.ActionHeader `actionType:"END_BLOCK"`
 }
 
 type commitBlockAction struct {
-	vm.ActionHeader `actionType:"COMMIT_BLOCK"`
+	*vm.ActionHeader `actionType:"COMMIT_BLOCK"`
 }
 
 type afterCommitBlockAction struct {
-	vm.ActionHeader `actionType:"AFTER_COMMIT_BLOCK"`
+	*vm.ActionHeader `actionType:"AFTER_COMMIT_BLOCK"`
 }
 
 func BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock, keeper Keeper) error {
 	defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), telemetry.MetricKeyBeginBlocker)
 
-	action := &beginBlockAction{
+	action := beginBlockAction{
 		ChainID: ctx.ChainID(),
 		Params:  keeper.GetParams(ctx),
 	}
@@ -56,7 +56,7 @@ var endBlockTime int64
 func EndBlock(ctx sdk.Context, req abci.RequestEndBlock, keeper Keeper) ([]abci.ValidatorUpdate, error) {
 	defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), telemetry.MetricKeyEndBlocker)
 
-	action := &endBlockAction{}
+	action := endBlockAction{}
 	_, err := keeper.BlockingSend(ctx, action)
 
 	// fmt.Fprintf(os.Stderr, "END_BLOCK Returned from SwingSet: %s, %v\n", out, err)
@@ -83,7 +83,7 @@ func getEndBlockContext() sdk.Context {
 func CommitBlock(keeper Keeper) error {
 	defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), "commit_blocker")
 
-	action := &commitBlockAction{}
+	action := commitBlockAction{}
 	_, err := keeper.BlockingSend(getEndBlockContext(), action)
 
 	// fmt.Fprintf(os.Stderr, "COMMIT_BLOCK Returned from SwingSet: %s, %v\n", out, err)
@@ -98,7 +98,7 @@ func CommitBlock(keeper Keeper) error {
 func AfterCommitBlock(keeper Keeper) error {
 	// defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), "commit_blocker")
 
-	action := &afterCommitBlockAction{}
+	action := afterCommitBlockAction{}
 	_, err := keeper.BlockingSend(getEndBlockContext(), action)
 
 	// fmt.Fprintf(os.Stderr, "AFTER_COMMIT_BLOCK Returned from SwingSet: %s, %v\n", out, err)

package/x/swingset/alias.go

@@ -24,6 +24,8 @@ type (
 	Keeper                   = keeper.Keeper
 	SwingStoreExportsHandler = keeper.SwingStoreExportsHandler
 	ExtensionSnapshotter     = keeper.ExtensionSnapshotter
+	ActionContext            = types.ActionContext
+	InboundQueueRecord       = types.InboundQueueRecord
 	Egress                   = types.Egress
 	MsgDeliverInbound        = types.MsgDeliverInbound
 	MsgProvision             = types.MsgProvision

package/x/swingset/client/cli/tx.go

@@ -253,11 +253,13 @@ Specify at least one pair of permit.json and code.js files`,
 				return err
 			}
 
+			//nolint:staticcheck // Agoric is still using the legacy proposal shape
 			title, err := cmd.Flags().GetString(govcli.FlagTitle)
 			if err != nil {
 				return err
 			}
 
+			//nolint:staticcheck // Agoric is still using the legacy proposal shape
 			description, err := cmd.Flags().GetString(govcli.FlagDescription)
 			if err != nil {
 				return err
@@ -315,7 +317,9 @@ Specify at least one pair of permit.json and code.js files`,
 		},
 	}
 
+	//nolint:staticcheck // Agoric is still using the legacy proposal shape
 	cmd.Flags().String(govcli.FlagTitle, "", "title of proposal")
+	//nolint:staticcheck // Agoric is still using the legacy proposal shape
 	cmd.Flags().String(govcli.FlagDescription, "", "description of proposal")
 	cmd.Flags().String(govcli.FlagDeposit, "", "deposit for proposal")