@agoric/cosmos 0.34.2-dev-5dc325b.0 → 0.35.0-getting-started-dev-26244e8.0

package/vm/jsonrpcconn/jsonrpcconn.go

@@ -1,160 +0,0 @@
-/*
-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

@@ -1,126 +0,0 @@
-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/server.go

@@ -1,23 +0,0 @@
-package vm
-
-import (
-	"fmt"
-)
-
-type AgdServer struct {}
-
-func NewAgdServer() *AgdServer {
-	return &AgdServer{}
-}
-
-// ReceiveMessage is the method the VM calls in order to have agd receive a
-// Message.
-func (s AgdServer) ReceiveMessage(msg *Message, reply *string) error {
-	handler := portToHandler[msg.Port]
-	if handler == nil {
-		return fmt.Errorf("unregistered port %d", msg.Port)
-	}
-	resp, err := handler.Receive(controllerContext, msg.Data)
-	*reply = resp
-	return err
-}

package/x/vstorage/README.md

@@ -1,140 +0,0 @@
-# Virtual Storage
-
-This module manages "[IAVL](https://github.com/cosmos/iavl)" chain storage data with a hierarchical keyspace in which each key is a "[path](./types/path_keys.go)" composed of zero or more dot-separated nonempty segments in a restricted alphabet. It exposes gRPC endpoints to arbitrary external clients for reading data, and internal read/write interfaces for use by SwingSet (which itself manages further subtree-scoped attenuation).
-
-## Internal Go interface
-
-[Keeper](./keeper/keeper.go)
-* generic
-  * GetChildren
-  * GetEntry
-  * HasEntry
-  * HasStorage
-  * SetStorage[AndNotify]
-* StreamCell-oriented (a StreamCell captures a block height and an array of values)
-  * AppendStorageValue[AndNotify]
-* queue-oriented (a queue stores items at paths like "$prefix.$n", documenting
-  the n for the next item to be consumed at "$prefix.head" and the n for the next
-  next item to be pushed at "$prefix.tail" such that the queue is empty when both
-  head and tail store the same n)
-  * GetQueueLength
-  * PushQueueItem
-
-## Internal JSON interface
-
-This is used by the SwingSet "bridge".
-
-[Receive](./vstorage.go) with input `{ "method": "...", "args": [...] }`
-* generic
-  * method "entries", args path
-  * method "get"/"has", args path
-  * method "set"/"setWithoutNotify", args [[path, value?], ...]
-  * method "children", args path
-  * method "values", args path (returns values for children in the same order as method "children")
-  * method "size", args path (returns the count of children)
-* StreamCell-oriented
-  * method "append", args [[path, value?], ...]
- 
-## CLI
-
-A blockchain node may be interrogated by RPC using `agd [--node $url] query vstorage $command` via [client/cli](./client/cli/query.go).
-* `children [--height $blockHeight] [-o {text,json}] [$path]`
-* `data [--height $blockHeight] [-o {text,json}] $path`
-
-Examples:
-```sh
-$ agd --node https://main.rpc.agoric.net:443/ query vstorage children published.reserve
-children:
-- governance
-- metrics
-pagination: null
-
-$ agd --node https://main.rpc.agoric.net:443/ query vstorage children -o json published.reserve
-{"children":["governance","metrics"],"pagination":null}
-
-$ agd --node https://main.rpc.agoric.net:443/ query vstorage data published.reserve.metrics
-value: '{"blockHeight":"11030240","values":["{\"body\":\"#{\\\"allocations\\\":{\\\"Fee\\\":{\\\"brand\\\":\\\"$0.Alleged:
-  IST brand\\\",\\\"value\\\":\\\"+20053582387\\\"}},\\\"shortfallBalance\\\":{\\\"brand\\\":\\\"$0\\\",\\\"value\\\":\\\"+0\\\"},\\\"totalFeeBurned\\\":{\\\"brand\\\":\\\"$0\\\",\\\"value\\\":\\\"+0\\\"},\\\"totalFeeMinted\\\":{\\\"brand\\\":\\\"$0\\\",\\\"value\\\":\\\"+0\\\"}}\",\"slots\":[\"board0257\"]}"]}'
-```
-
-## External protobuf interface
-
-RPC via [Querier](./keeper/grpc_query.go),
-and [CometBFT method "abci_query"](https://docs.cometbft.com/main/rpc/#/ABCI/abci_query)
-with params `path` "/agoric.vstorage.Query/..."
-and `data` \<serialized protobuf per [vstorage/query.proto](../../proto/agoric/vstorage/query.proto)>
-(also via [Querier](./keeper/grpc_query.go))
-* /agoric.vstorage.Query/CapData
-* /agoric.vstorage.Query/Children
-* /agoric.vstorage.Query/Data
-
-Example:
-```sh
-$ curl -sS 'https://main.rpc.agoric.net/' -H 'Content-Type: application/json' -X POST --data "$(
-    jq -n --arg queryChildrenRequestHex 0a147075626c69736865642e636f6d6d697474656573 '{
-      id: 1,
-      method: "abci_query",
-      params: { path: "/agoric.vstorage.Query/Children", data: $queryChildrenRequestHex }
-    }' | \
-    tee /dev/stderr \
-  )" | \
-  jq . | \
-  tee /dev/stderr | \
-  jq -r '.result.response.value' | \
-  base64 -d | \
-  protoc -I golang/cosmos/proto/agoric/vstorage/ -I golang/cosmos/third_party/proto/ \
-    --decode=agoric.vstorage.QueryChildrenResponse golang/cosmos/proto/agoric/vstorage/query.proto 
-{
-  "id": 1,
-  "method": "abci_query",
-  "params": {
-    "path": "/agoric.vstorage.Query/Children",
-    "data": "0a147075626c69736865642e636f6d6d697474656573"
-  }
-}
-{
-  "jsonrpc": "2.0",
-  "id": 1,
-  "result": {
-    "response": {
-      "code": 0,
-      "log": "",
-      "info": "",
-      "index": "0",
-      "key": null,
-      "value": "ChJFY29ub21pY19Db21taXR0ZWUKCWtyZWFkLWdvdg==",
-      "proofOps": null,
-      "height": "12222836",
-      "codespace": ""
-    }
-  }
-}
-children: "Economic_Committee"
-children: "kread-gov"
-```
-
-## External JSON interface
-
-As described at [Cosmos SDK: Using the REST Endpoints](https://docs.cosmos.network/main/run-node/interact-node#using-the-rest-endpoints), a blockchain node whose [`app.toml` configuration](https://docs.cosmos.network/main/run-node/run-node#configuring-the-node-using-apptoml-and-configtoml) enables the "REST" API server uses [gRPC-Gateway](https://grpc-ecosystem.github.io/grpc-gateway/) and `google.api.http` annotations in [vstorage/query.proto](../../proto/agoric/vstorage/query.proto) to automatically translate the protobuf-based RPC endpoints into URL paths that accept query parameters and emit JSON.
-* /agoric/vstorage/capdata/$path?remotableValueFormat={object,string}[&mediaType=JSON%20Lines][&itemFormat=flat]
-* /agoric/vstorage/children/$path
-* /agoric/vstorage/data/$path
-
-Example:
-```sh
-$ curl -sS 'https://main.api.agoric.net/agoric/vstorage/children/published.committees'
-{
-  "children": [
-    "Economic_Committee"
-  ],
-  "pagination": null
-}
-```
-
-## Arbitrary-response HTTP interface
-
-This depends upon appModule `LegacyQuerierHandler` functionality that is [removed from cosmos-sdk as of v0.47](https://github.com/cosmos/cosmos-sdk/blob/fa4d87ef7e6d87aaccc94c337ffd2fe90fcb7a9d/CHANGELOG.md#api-breaking-changes-3)
-
-[legacy querier](./keeper/querier.go)
-* /custom/vstorage/children/$path
-* /custom/vstorage/data/$path