diff --git a/go.mod b/go.mod
index 356f4bc28e..9756575231 100644
--- a/go.mod
+++ b/go.mod
@@ -66,8 +66,8 @@ require (
github.com/cosmos/ledger-cosmos-go v0.11.1 // indirect
github.com/cosmos/ledger-go v0.9.2 // indirect
github.com/danieljoos/wincred v1.0.2 // indirect
- github.com/davecgh/go-spew v1.1.1 // indirect
- github.com/deckarep/golang-set v1.8.0 // indirect
+ github.com/davecgh/go-spew v1.1.1
+ github.com/deckarep/golang-set v1.8.0
github.com/desertbit/timer v0.0.0-20180107155436-c41aec40b27f // indirect
github.com/dgraph-io/badger/v2 v2.2007.2 // indirect
github.com/dgraph-io/ristretto v0.0.3 // indirect
@@ -99,7 +99,7 @@ require (
github.com/google/orderedcode v0.0.1 // indirect
github.com/gookit/color v1.5.0 // indirect
github.com/gorilla/handlers v1.5.1 // indirect
- github.com/gorilla/websocket v1.5.0 // indirect
+ github.com/gorilla/websocket v1.5.0
github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 // indirect
github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c // indirect
github.com/gtank/merlin v0.1.1 // indirect
@@ -190,7 +190,7 @@ require (
golang.org/x/text v0.3.7 // indirect
golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
gopkg.in/ini.v1 v1.66.3 // indirect
- gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
+ gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce
gopkg.in/warnings.v0 v0.1.2 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
nhooyr.io/websocket v1.8.6 // indirect
diff --git a/relayer/chainproxy/connector.go b/relayer/chainproxy/connector.go
index 8c7e10a228..9e4a7c3050 100644
--- a/relayer/chainproxy/connector.go
+++ b/relayer/chainproxy/connector.go
@@ -12,22 +12,22 @@ import (
"sync"
"time"
- "github.com/ethereum/go-ethereum/rpc"
+ "github.com/lavanet/lava/relayer/chainproxy/rpcclient"
)
type Connector struct {
lock sync.Mutex
- freeClients []*rpc.Client
+ freeClients []*rpcclient.Client
usedClients int
}
func NewConnector(ctx context.Context, nConns uint, addr string) *Connector {
connector := &Connector{
- freeClients: make([]*rpc.Client, 0, nConns),
+ freeClients: make([]*rpcclient.Client, 0, nConns),
}
for i := uint(0); i < nConns; i++ {
- var rpcClient *rpc.Client
+ var rpcClient *rpcclient.Client
var err error
for {
if ctx.Err() != nil {
@@ -35,7 +35,7 @@ func NewConnector(ctx context.Context, nConns uint, addr string) *Connector {
return nil
}
nctx, cancel := context.WithTimeout(ctx, 500*time.Millisecond)
- rpcClient, err = rpc.DialContext(nctx, addr)
+ rpcClient, err = rpcclient.DialContext(nctx, addr)
if err != nil {
log.Println("retrying", err)
cancel()
@@ -64,7 +64,7 @@ func (connector *Connector) Close() {
for i := 0; i < len(connector.freeClients); i++ {
connector.freeClients[i].Close()
}
- connector.freeClients = []*rpc.Client{}
+ connector.freeClients = []*rpcclient.Client{}
if connector.usedClients > 0 {
log.Println("Connector closing, waiting for in use clients", connector.usedClients)
@@ -77,7 +77,7 @@ func (connector *Connector) Close() {
}
}
-func (connector *Connector) GetRpc(block bool) (*rpc.Client, error) {
+func (connector *Connector) GetRpc(block bool) (*rpcclient.Client, error) {
connector.lock.Lock()
defer connector.lock.Unlock()
countPrint := 0
@@ -107,7 +107,7 @@ func (connector *Connector) GetRpc(block bool) (*rpc.Client, error) {
return ret, nil
}
-func (connector *Connector) ReturnRpc(rpc *rpc.Client) {
+func (connector *Connector) ReturnRpc(rpc *rpcclient.Client) {
connector.lock.Lock()
defer connector.lock.Unlock()
diff --git a/relayer/chainproxy/rpcclient/client.go b/relayer/chainproxy/rpcclient/client.go
new file mode 100755
index 0000000000..03a2b3cebd
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/client.go
@@ -0,0 +1,643 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "context"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "net/url"
+ "reflect"
+ "strconv"
+ "sync/atomic"
+ "time"
+
+ "github.com/ethereum/go-ethereum/log"
+)
+
+var (
+ ErrClientQuit = errors.New("client is closed")
+ ErrNoResult = errors.New("no result in JSON-RPC response")
+ ErrSubscriptionQueueOverflow = errors.New("subscription queue overflow")
+ errClientReconnected = errors.New("client reconnected")
+ errDead = errors.New("connection lost")
+)
+
+const (
+ // Timeouts
+ defaultDialTimeout = 10 * time.Second // used if context has no deadline
+ subscribeTimeout = 5 * time.Second // overall timeout eth_subscribe, rpc_modules calls
+)
+
+const (
+ // Subscriptions are removed when the subscriber cannot keep up.
+ //
+ // This can be worked around by supplying a channel with sufficiently sized buffer,
+ // but this can be inconvenient and hard to explain in the docs. Another issue with
+ // buffered channels is that the buffer is static even though it might not be needed
+ // most of the time.
+ //
+ // The approach taken here is to maintain a per-subscription linked list buffer
+ // shrinks on demand. If the buffer reaches the size below, the subscription is
+ // dropped.
+ maxClientSubscriptionBuffer = 20000
+)
+
+// BatchElem is an element in a batch request.
+type BatchElem struct {
+ Method string
+ Args []interface{}
+ // The result is unmarshaled into this field. Result must be set to a
+ // non-nil pointer value of the desired type, otherwise the response will be
+ // discarded.
+ Result interface{}
+ // Error is set if the server returns an error for this request, or if
+ // unmarshaling into Result fails. It is not set for I/O errors.
+ Error error
+}
+
+// Client represents a connection to an RPC server.
+type Client struct {
+ idgen func() ID // for subscriptions
+ isHTTP bool // connection type: http, ws or ipc
+ services *serviceRegistry
+
+ idCounter uint32
+
+ // This function, if non-nil, is called when the connection is lost.
+ reconnectFunc reconnectFunc
+
+ // writeConn is used for writing to the connection on the caller's goroutine. It should
+ // only be accessed outside of dispatch, with the write lock held. The write lock is
+ // taken by sending on reqInit and released by sending on reqSent.
+ writeConn jsonWriter
+
+ // for dispatch
+ close chan struct{}
+ closing chan struct{} // closed when client is quitting
+ didClose chan struct{} // closed when client quits
+ reconnected chan ServerCodec // where write/reconnect sends the new connection
+ readOp chan readOp // read messages
+ readErr chan error // errors from read
+ reqInit chan *requestOp // register response IDs, takes write lock
+ reqSent chan error // signals write completion, releases write lock
+ reqTimeout chan *requestOp // removes response IDs when call timeout expires
+}
+
+type reconnectFunc func(ctx context.Context) (ServerCodec, error)
+
+type clientContextKey struct{}
+
+type clientConn struct {
+ codec ServerCodec
+ handler *handler
+}
+
+func (c *Client) newClientConn(conn ServerCodec) *clientConn {
+ ctx := context.Background()
+ ctx = context.WithValue(ctx, clientContextKey{}, c)
+ ctx = context.WithValue(ctx, peerInfoContextKey{}, conn.peerInfo())
+ handler := newHandler(ctx, conn, c.idgen, c.services)
+ return &clientConn{conn, handler}
+}
+
+func (cc *clientConn) close(err error, inflightReq *requestOp) {
+ cc.handler.close(err, inflightReq)
+ cc.codec.close()
+}
+
+type readOp struct {
+ msgs []*jsonrpcMessage
+ batch bool
+}
+
+type requestOp struct {
+ ids []json.RawMessage
+ err error
+ resp chan *jsonrpcMessage // receives up to len(ids) responses
+ sub *ClientSubscription // only set for EthSubscribe requests
+}
+
+func (op *requestOp) wait(ctx context.Context, c *Client) (*jsonrpcMessage, error) {
+ select {
+ case <-ctx.Done():
+ // Send the timeout to dispatch so it can remove the request IDs.
+ if !c.isHTTP {
+ select {
+ case c.reqTimeout <- op:
+ case <-c.closing:
+ }
+ }
+ return nil, ctx.Err()
+ case resp := <-op.resp:
+ return resp, op.err
+ }
+}
+
+// Dial creates a new client for the given URL.
+//
+// The currently supported URL schemes are "http", "https", "ws" and "wss". If rawurl is a
+// file name with no URL scheme, a local socket connection is established using UNIX
+// domain sockets on supported platforms and named pipes on Windows. If you want to
+// configure transport options, use DialHTTP, DialWebsocket or DialIPC instead.
+//
+// For websocket connections, the origin is set to the local host name.
+//
+// The client reconnects automatically if the connection is lost.
+func Dial(rawurl string) (*Client, error) {
+ return DialContext(context.Background(), rawurl)
+}
+
+// DialContext creates a new RPC client, just like Dial.
+//
+// The context is used to cancel or time out the initial connection establishment. It does
+// not affect subsequent interactions with the client.
+func DialContext(ctx context.Context, rawurl string) (*Client, error) {
+ u, err := url.Parse(rawurl)
+ if err != nil {
+ return nil, err
+ }
+ switch u.Scheme {
+ case "http", "https":
+ return DialHTTP(rawurl)
+ case "ws", "wss":
+ return DialWebsocket(ctx, rawurl, "")
+ case "stdio":
+ return DialStdIO(ctx)
+ case "":
+ return DialIPC(ctx, rawurl)
+ default:
+ return nil, fmt.Errorf("no known transport for URL scheme %q", u.Scheme)
+ }
+}
+
+// ClientFromContext retrieves the client from the context, if any. This can be used to perform
+// 'reverse calls' in a handler method.
+func ClientFromContext(ctx context.Context) (*Client, bool) {
+ client, ok := ctx.Value(clientContextKey{}).(*Client)
+ return client, ok
+}
+
+func newClient(initctx context.Context, connect reconnectFunc) (*Client, error) {
+ conn, err := connect(initctx)
+ if err != nil {
+ return nil, err
+ }
+ c := initClient(conn, randomIDGenerator(), new(serviceRegistry))
+ c.reconnectFunc = connect
+ return c, nil
+}
+
+func initClient(conn ServerCodec, idgen func() ID, services *serviceRegistry) *Client {
+ _, isHTTP := conn.(*httpConn)
+ c := &Client{
+ isHTTP: isHTTP,
+ idgen: idgen,
+ services: services,
+ writeConn: conn,
+ close: make(chan struct{}),
+ closing: make(chan struct{}),
+ didClose: make(chan struct{}),
+ reconnected: make(chan ServerCodec),
+ readOp: make(chan readOp),
+ readErr: make(chan error),
+ reqInit: make(chan *requestOp),
+ reqSent: make(chan error, 1),
+ reqTimeout: make(chan *requestOp),
+ }
+ if !isHTTP {
+ go c.dispatch(conn)
+ }
+ return c
+}
+
+// RegisterName creates a service for the given receiver type under the given name. When no
+// methods on the given receiver match the criteria to be either a RPC method or a
+// subscription an error is returned. Otherwise a new service is created and added to the
+// service collection this client provides to the server.
+func (c *Client) RegisterName(name string, receiver interface{}) error {
+ return c.services.registerName(name, receiver)
+}
+
+func (c *Client) nextID() json.RawMessage {
+ id := atomic.AddUint32(&c.idCounter, 1)
+ return strconv.AppendUint(nil, uint64(id), 10)
+}
+
+// SupportedModules calls the rpc_modules method, retrieving the list of
+// APIs that are available on the server.
+func (c *Client) SupportedModules() (map[string]string, error) {
+ var result map[string]string
+ ctx, cancel := context.WithTimeout(context.Background(), subscribeTimeout)
+ defer cancel()
+ err := c.CallContext(ctx, &result, "rpc_modules")
+ return result, err
+}
+
+// Close closes the client, aborting any in-flight requests.
+func (c *Client) Close() {
+ if c.isHTTP {
+ return
+ }
+ select {
+ case c.close <- struct{}{}:
+ <-c.didClose
+ case <-c.didClose:
+ }
+}
+
+// SetHeader adds a custom HTTP header to the client's requests.
+// This method only works for clients using HTTP, it doesn't have
+// any effect for clients using another transport.
+func (c *Client) SetHeader(key, value string) {
+ if !c.isHTTP {
+ return
+ }
+ conn := c.writeConn.(*httpConn)
+ conn.mu.Lock()
+ conn.headers.Set(key, value)
+ conn.mu.Unlock()
+}
+
+// Call performs a JSON-RPC call with the given arguments and unmarshals into
+// result if no error occurred.
+//
+// The result must be a pointer so that package json can unmarshal into it. You
+// can also pass nil, in which case the result is ignored.
+func (c *Client) Call(result interface{}, method string, args ...interface{}) error {
+ ctx := context.Background()
+ return c.CallContext(ctx, result, method, args...)
+}
+
+// CallContext performs a JSON-RPC call with the given arguments. If the context is
+// canceled before the call has successfully returned, CallContext returns immediately.
+//
+// The result must be a pointer so that package json can unmarshal into it. You
+// can also pass nil, in which case the result is ignored.
+func (c *Client) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error {
+ if result != nil && reflect.TypeOf(result).Kind() != reflect.Ptr {
+ return fmt.Errorf("call result parameter must be pointer or nil interface: %v", result)
+ }
+ msg, err := c.newMessage(method, args...)
+ if err != nil {
+ return err
+ }
+ op := &requestOp{ids: []json.RawMessage{msg.ID}, resp: make(chan *jsonrpcMessage, 1)}
+
+ if c.isHTTP {
+ err = c.sendHTTP(ctx, op, msg)
+ } else {
+ err = c.send(ctx, op, msg)
+ }
+ if err != nil {
+ return err
+ }
+
+ // dispatch has accepted the request and will close the channel when it quits.
+ switch resp, err := op.wait(ctx, c); {
+ case err != nil:
+ return err
+ case resp.Error != nil:
+ return resp.Error
+ case len(resp.Result) == 0:
+ return ErrNoResult
+ default:
+ return json.Unmarshal(resp.Result, &result)
+ }
+}
+
+// BatchCall sends all given requests as a single batch and waits for the server
+// to return a response for all of them.
+//
+// In contrast to Call, BatchCall only returns I/O errors. Any error specific to
+// a request is reported through the Error field of the corresponding BatchElem.
+//
+// Note that batch calls may not be executed atomically on the server side.
+func (c *Client) BatchCall(b []BatchElem) error {
+ ctx := context.Background()
+ return c.BatchCallContext(ctx, b)
+}
+
+// BatchCallContext sends all given requests as a single batch and waits for the server
+// to return a response for all of them. The wait duration is bounded by the
+// context's deadline.
+//
+// In contrast to CallContext, BatchCallContext only returns errors that have occurred
+// while sending the request. Any error specific to a request is reported through the
+// Error field of the corresponding BatchElem.
+//
+// Note that batch calls may not be executed atomically on the server side.
+func (c *Client) BatchCallContext(ctx context.Context, b []BatchElem) error {
+ var (
+ msgs = make([]*jsonrpcMessage, len(b))
+ byID = make(map[string]int, len(b))
+ )
+ op := &requestOp{
+ ids: make([]json.RawMessage, len(b)),
+ resp: make(chan *jsonrpcMessage, len(b)),
+ }
+ for i, elem := range b {
+ msg, err := c.newMessage(elem.Method, elem.Args...)
+ if err != nil {
+ return err
+ }
+ msgs[i] = msg
+ op.ids[i] = msg.ID
+ byID[string(msg.ID)] = i
+ }
+
+ var err error
+ if c.isHTTP {
+ err = c.sendBatchHTTP(ctx, op, msgs)
+ } else {
+ err = c.send(ctx, op, msgs)
+ }
+
+ // Wait for all responses to come back.
+ for n := 0; n < len(b) && err == nil; n++ {
+ var resp *jsonrpcMessage
+ resp, err = op.wait(ctx, c)
+ if err != nil {
+ break
+ }
+ // Find the element corresponding to this response.
+ // The element is guaranteed to be present because dispatch
+ // only sends valid IDs to our channel.
+ elem := &b[byID[string(resp.ID)]]
+ if resp.Error != nil {
+ elem.Error = resp.Error
+ continue
+ }
+ if len(resp.Result) == 0 {
+ elem.Error = ErrNoResult
+ continue
+ }
+ elem.Error = json.Unmarshal(resp.Result, elem.Result)
+ }
+ return err
+}
+
+// Notify sends a notification, i.e. a method call that doesn't expect a response.
+func (c *Client) Notify(ctx context.Context, method string, args ...interface{}) error {
+ op := new(requestOp)
+ msg, err := c.newMessage(method, args...)
+ if err != nil {
+ return err
+ }
+ msg.ID = nil
+
+ if c.isHTTP {
+ return c.sendHTTP(ctx, op, msg)
+ }
+ return c.send(ctx, op, msg)
+}
+
+// EthSubscribe registers a subscription under the "eth" namespace.
+func (c *Client) EthSubscribe(ctx context.Context, channel interface{}, args ...interface{}) (*ClientSubscription, error) {
+ return c.Subscribe(ctx, "eth", channel, args...)
+}
+
+// ShhSubscribe registers a subscription under the "shh" namespace.
+// Deprecated: use Subscribe(ctx, "shh", ...).
+func (c *Client) ShhSubscribe(ctx context.Context, channel interface{}, args ...interface{}) (*ClientSubscription, error) {
+ return c.Subscribe(ctx, "shh", channel, args...)
+}
+
+// Subscribe calls the "_subscribe" method with the given arguments,
+// registering a subscription. Server notifications for the subscription are
+// sent to the given channel. The element type of the channel must match the
+// expected type of content returned by the subscription.
+//
+// The context argument cancels the RPC request that sets up the subscription but has no
+// effect on the subscription after Subscribe has returned.
+//
+// Slow subscribers will be dropped eventually. Client buffers up to 20000 notifications
+// before considering the subscriber dead. The subscription Err channel will receive
+// ErrSubscriptionQueueOverflow. Use a sufficiently large buffer on the channel or ensure
+// that the channel usually has at least one reader to prevent this issue.
+func (c *Client) Subscribe(ctx context.Context, namespace string, channel interface{}, args ...interface{}) (*ClientSubscription, error) {
+ // Check type of channel first.
+ chanVal := reflect.ValueOf(channel)
+ if chanVal.Kind() != reflect.Chan || chanVal.Type().ChanDir()&reflect.SendDir == 0 {
+ panic(fmt.Sprintf("channel argument of Subscribe has type %T, need writable channel", channel))
+ }
+ if chanVal.IsNil() {
+ panic("channel given to Subscribe must not be nil")
+ }
+ if c.isHTTP {
+ return nil, ErrNotificationsUnsupported
+ }
+
+ msg, err := c.newMessage(namespace+subscribeMethodSuffix, args...)
+ if err != nil {
+ return nil, err
+ }
+ op := &requestOp{
+ ids: []json.RawMessage{msg.ID},
+ resp: make(chan *jsonrpcMessage),
+ sub: newClientSubscription(c, namespace, chanVal),
+ }
+
+ // Send the subscription request.
+ // The arrival and validity of the response is signaled on sub.quit.
+ if err := c.send(ctx, op, msg); err != nil {
+ return nil, err
+ }
+ if _, err := op.wait(ctx, c); err != nil {
+ return nil, err
+ }
+ return op.sub, nil
+}
+
+func (c *Client) newMessage(method string, paramsIn ...interface{}) (*jsonrpcMessage, error) {
+ msg := &jsonrpcMessage{Version: vsn, ID: c.nextID(), Method: method}
+ if paramsIn != nil { // prevent sending "params":null
+ var err error
+ if msg.Params, err = json.Marshal(paramsIn); err != nil {
+ return nil, err
+ }
+ }
+ return msg, nil
+}
+
+// send registers op with the dispatch loop, then sends msg on the connection.
+// if sending fails, op is deregistered.
+func (c *Client) send(ctx context.Context, op *requestOp, msg interface{}) error {
+ select {
+ case c.reqInit <- op:
+ err := c.write(ctx, msg, false)
+ c.reqSent <- err
+ return err
+ case <-ctx.Done():
+ // This can happen if the client is overloaded or unable to keep up with
+ // subscription notifications.
+ return ctx.Err()
+ case <-c.closing:
+ return ErrClientQuit
+ }
+}
+
+func (c *Client) write(ctx context.Context, msg interface{}, retry bool) error {
+ if c.writeConn == nil {
+ // The previous write failed. Try to establish a new connection.
+ if err := c.reconnect(ctx); err != nil {
+ return err
+ }
+ }
+ err := c.writeConn.writeJSON(ctx, msg)
+ if err != nil {
+ c.writeConn = nil
+ if !retry {
+ return c.write(ctx, msg, true)
+ }
+ }
+ return err
+}
+
+func (c *Client) reconnect(ctx context.Context) error {
+ if c.reconnectFunc == nil {
+ return errDead
+ }
+
+ if _, ok := ctx.Deadline(); !ok {
+ var cancel func()
+ ctx, cancel = context.WithTimeout(ctx, defaultDialTimeout)
+ defer cancel()
+ }
+ newconn, err := c.reconnectFunc(ctx)
+ if err != nil {
+ log.Trace("RPC client reconnect failed", "err", err)
+ return err
+ }
+ select {
+ case c.reconnected <- newconn:
+ c.writeConn = newconn
+ return nil
+ case <-c.didClose:
+ newconn.close()
+ return ErrClientQuit
+ }
+}
+
+// dispatch is the main loop of the client.
+// It sends read messages to waiting calls to Call and BatchCall
+// and subscription notifications to registered subscriptions.
+func (c *Client) dispatch(codec ServerCodec) {
+ var (
+ lastOp *requestOp // tracks last send operation
+ reqInitLock = c.reqInit // nil while the send lock is held
+ conn = c.newClientConn(codec)
+ reading = true
+ )
+ defer func() {
+ close(c.closing)
+ if reading {
+ conn.close(ErrClientQuit, nil)
+ c.drainRead()
+ }
+ close(c.didClose)
+ }()
+
+ // Spawn the initial read loop.
+ go c.read(codec)
+
+ for {
+ select {
+ case <-c.close:
+ return
+
+ // Read path:
+ case op := <-c.readOp:
+ if op.batch {
+ conn.handler.handleBatch(op.msgs)
+ } else {
+ conn.handler.handleMsg(op.msgs[0])
+ }
+
+ case err := <-c.readErr:
+ conn.handler.log.Debug("RPC connection read error", "err", err)
+ conn.close(err, lastOp)
+ reading = false
+
+ // Reconnect:
+ case newcodec := <-c.reconnected:
+ log.Debug("RPC client reconnected", "reading", reading, "conn", newcodec.remoteAddr())
+ if reading {
+ // Wait for the previous read loop to exit. This is a rare case which
+ // happens if this loop isn't notified in time after the connection breaks.
+ // In those cases the caller will notice first and reconnect. Closing the
+ // handler terminates all waiting requests (closing op.resp) except for
+ // lastOp, which will be transferred to the new handler.
+ conn.close(errClientReconnected, lastOp)
+ c.drainRead()
+ }
+ go c.read(newcodec)
+ reading = true
+ conn = c.newClientConn(newcodec)
+ // Re-register the in-flight request on the new handler
+ // because that's where it will be sent.
+ conn.handler.addRequestOp(lastOp)
+
+ // Send path:
+ case op := <-reqInitLock:
+ // Stop listening for further requests until the current one has been sent.
+ reqInitLock = nil
+ lastOp = op
+ conn.handler.addRequestOp(op)
+
+ case err := <-c.reqSent:
+ if err != nil {
+ // Remove response handlers for the last send. When the read loop
+ // goes down, it will signal all other current operations.
+ conn.handler.removeRequestOp(lastOp)
+ }
+ // Let the next request in.
+ reqInitLock = c.reqInit
+ lastOp = nil
+
+ case op := <-c.reqTimeout:
+ conn.handler.removeRequestOp(op)
+ }
+ }
+}
+
+// drainRead drops read messages until an error occurs.
+func (c *Client) drainRead() {
+ for {
+ select {
+ case <-c.readOp:
+ case <-c.readErr:
+ return
+ }
+ }
+}
+
+// read decodes RPC messages from a codec, feeding them into dispatch.
+func (c *Client) read(codec ServerCodec) {
+ for {
+ msgs, batch, err := codec.readBatch()
+ if _, ok := err.(*json.SyntaxError); ok {
+ codec.writeJSON(context.Background(), errorMessage(&parseError{err.Error()}))
+ }
+ if err != nil {
+ c.readErr <- err
+ return
+ }
+ c.readOp <- readOp{msgs, batch}
+ }
+}
diff --git a/relayer/chainproxy/rpcclient/client_example_test.go b/relayer/chainproxy/rpcclient/client_example_test.go
new file mode 100755
index 0000000000..2535c82a83
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/client_example_test.go
@@ -0,0 +1,89 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient_test
+
+import (
+ "context"
+ "fmt"
+ "time"
+
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ethereum/go-ethereum/rpc"
+)
+
+// In this example, our client wishes to track the latest 'block number'
+// known to the server. The server supports two methods:
+//
+// eth_getBlockByNumber("latest", {})
+// returns the latest block object.
+//
+// eth_subscribe("newHeads")
+// creates a subscription which fires block objects when new blocks arrive.
+
+type Block struct {
+ Number *hexutil.Big
+}
+
+func ExampleClientSubscription() {
+ // Connect the client.
+ client, _ := rpc.Dial("ws://127.0.0.1:8545")
+ subch := make(chan Block)
+
+ // Ensure that subch receives the latest block.
+ go func() {
+ for i := 0; ; i++ {
+ if i > 0 {
+ time.Sleep(2 * time.Second)
+ }
+ subscribeBlocks(client, subch)
+ }
+ }()
+
+ // Print events from the subscription as they arrive.
+ for block := range subch {
+ fmt.Println("latest block:", block.Number)
+ }
+}
+
+// subscribeBlocks runs in its own goroutine and maintains
+// a subscription for new blocks.
+func subscribeBlocks(client *rpc.Client, subch chan Block) {
+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+ defer cancel()
+
+ // Subscribe to new blocks.
+ sub, err := client.EthSubscribe(ctx, subch, "newHeads")
+ if err != nil {
+ fmt.Println("subscribe error:", err)
+ return
+ }
+
+ // The connection is established now.
+ // Update the channel with the current block.
+ var lastBlock Block
+ err = client.CallContext(ctx, &lastBlock, "eth_getBlockByNumber", "latest", false)
+ if err != nil {
+ fmt.Println("can't get latest block:", err)
+ return
+ }
+ subch <- lastBlock
+
+ // The subscription will deliver events to the channel. Wait for the
+ // subscription to end for any reason, then loop around to re-establish
+ // the connection.
+ fmt.Println("connection lost: ", <-sub.Err())
+}
diff --git a/relayer/chainproxy/rpcclient/client_test.go b/relayer/chainproxy/rpcclient/client_test.go
new file mode 100755
index 0000000000..f8a146d745
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/client_test.go
@@ -0,0 +1,740 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "math/rand"
+ "net"
+ "net/http"
+ "net/http/httptest"
+ "os"
+ "reflect"
+ "runtime"
+ "strings"
+ "sync"
+ "testing"
+ "time"
+
+ "github.com/davecgh/go-spew/spew"
+ "github.com/ethereum/go-ethereum/log"
+)
+
+func TestClientRequest(t *testing.T) {
+ server := newTestServer()
+ defer server.Stop()
+ client := DialInProc(server)
+ defer client.Close()
+
+ var resp echoResult
+ if err := client.Call(&resp, "test_echo", "hello", 10, &echoArgs{"world"}); err != nil {
+ t.Fatal(err)
+ }
+ if !reflect.DeepEqual(resp, echoResult{"hello", 10, &echoArgs{"world"}}) {
+ t.Errorf("incorrect result %#v", resp)
+ }
+}
+
+func TestClientResponseType(t *testing.T) {
+ server := newTestServer()
+ defer server.Stop()
+ client := DialInProc(server)
+ defer client.Close()
+
+ if err := client.Call(nil, "test_echo", "hello", 10, &echoArgs{"world"}); err != nil {
+ t.Errorf("Passing nil as result should be fine, but got an error: %v", err)
+ }
+ var resultVar echoResult
+ // Note: passing the var, not a ref
+ err := client.Call(resultVar, "test_echo", "hello", 10, &echoArgs{"world"})
+ if err == nil {
+ t.Error("Passing a var as result should be an error")
+ }
+}
+
+// This test checks that server-returned errors with code and data come out of Client.Call.
+func TestClientErrorData(t *testing.T) {
+ server := newTestServer()
+ defer server.Stop()
+ client := DialInProc(server)
+ defer client.Close()
+
+ var resp interface{}
+ err := client.Call(&resp, "test_returnError")
+ if err == nil {
+ t.Fatal("expected error")
+ }
+
+ // Check code.
+ if e, ok := err.(Error); !ok {
+ t.Fatalf("client did not return rpc.Error, got %#v", e)
+ } else if e.ErrorCode() != (testError{}.ErrorCode()) {
+ t.Fatalf("wrong error code %d, want %d", e.ErrorCode(), testError{}.ErrorCode())
+ }
+ // Check data.
+ if e, ok := err.(DataError); !ok {
+ t.Fatalf("client did not return rpc.DataError, got %#v", e)
+ } else if e.ErrorData() != (testError{}.ErrorData()) {
+ t.Fatalf("wrong error data %#v, want %#v", e.ErrorData(), testError{}.ErrorData())
+ }
+}
+
+func TestClientBatchRequest(t *testing.T) {
+ server := newTestServer()
+ defer server.Stop()
+ client := DialInProc(server)
+ defer client.Close()
+
+ batch := []BatchElem{
+ {
+ Method: "test_echo",
+ Args: []interface{}{"hello", 10, &echoArgs{"world"}},
+ Result: new(echoResult),
+ },
+ {
+ Method: "test_echo",
+ Args: []interface{}{"hello2", 11, &echoArgs{"world"}},
+ Result: new(echoResult),
+ },
+ {
+ Method: "no_such_method",
+ Args: []interface{}{1, 2, 3},
+ Result: new(int),
+ },
+ }
+ if err := client.BatchCall(batch); err != nil {
+ t.Fatal(err)
+ }
+ wantResult := []BatchElem{
+ {
+ Method: "test_echo",
+ Args: []interface{}{"hello", 10, &echoArgs{"world"}},
+ Result: &echoResult{"hello", 10, &echoArgs{"world"}},
+ },
+ {
+ Method: "test_echo",
+ Args: []interface{}{"hello2", 11, &echoArgs{"world"}},
+ Result: &echoResult{"hello2", 11, &echoArgs{"world"}},
+ },
+ {
+ Method: "no_such_method",
+ Args: []interface{}{1, 2, 3},
+ Result: new(int),
+ Error: &jsonError{Code: -32601, Message: "the method no_such_method does not exist/is not available"},
+ },
+ }
+ if !reflect.DeepEqual(batch, wantResult) {
+ t.Errorf("batch results mismatch:\ngot %swant %s", spew.Sdump(batch), spew.Sdump(wantResult))
+ }
+}
+
+func TestClientNotify(t *testing.T) {
+ server := newTestServer()
+ defer server.Stop()
+ client := DialInProc(server)
+ defer client.Close()
+
+ if err := client.Notify(context.Background(), "test_echo", "hello", 10, &echoArgs{"world"}); err != nil {
+ t.Fatal(err)
+ }
+}
+
+// func TestClientCancelInproc(t *testing.T) { testClientCancel("inproc", t) }
+func TestClientCancelWebsocket(t *testing.T) { testClientCancel("ws", t) }
+func TestClientCancelHTTP(t *testing.T) { testClientCancel("http", t) }
+func TestClientCancelIPC(t *testing.T) { testClientCancel("ipc", t) }
+
+// This test checks that requests made through CallContext can be canceled by canceling
+// the context.
+func testClientCancel(transport string, t *testing.T) {
+ // These tests take a lot of time, run them all at once.
+ // You probably want to run with -parallel 1 or comment out
+ // the call to t.Parallel if you enable the logging.
+ t.Parallel()
+
+ server := newTestServer()
+ defer server.Stop()
+
+ // What we want to achieve is that the context gets canceled
+ // at various stages of request processing. The interesting cases
+ // are:
+ // - cancel during dial
+ // - cancel while performing a HTTP request
+ // - cancel while waiting for a response
+ //
+ // To trigger those, the times are chosen such that connections
+ // are killed within the deadline for every other call (maxKillTimeout
+ // is 2x maxCancelTimeout).
+ //
+ // Once a connection is dead, there is a fair chance it won't connect
+ // successfully because the accept is delayed by 1s.
+ maxContextCancelTimeout := 300 * time.Millisecond
+ fl := &flakeyListener{
+ maxAcceptDelay: 1 * time.Second,
+ maxKillTimeout: 600 * time.Millisecond,
+ }
+
+ var client *Client
+ switch transport {
+ case "ws", "http":
+ c, hs := httpTestClient(server, transport, fl)
+ defer hs.Close()
+ client = c
+ case "ipc":
+ c, l := ipcTestClient(server, fl)
+ defer l.Close()
+ client = c
+ default:
+ panic("unknown transport: " + transport)
+ }
+
+ // The actual test starts here.
+ var (
+ wg sync.WaitGroup
+ nreqs = 10
+ ncallers = 10
+ )
+ caller := func(index int) {
+ defer wg.Done()
+ for i := 0; i < nreqs; i++ {
+ var (
+ ctx context.Context
+ cancel func()
+ timeout = time.Duration(rand.Int63n(int64(maxContextCancelTimeout)))
+ )
+ if index < ncallers/2 {
+ // For half of the callers, create a context without deadline
+ // and cancel it later.
+ ctx, cancel = context.WithCancel(context.Background())
+ time.AfterFunc(timeout, cancel)
+ } else {
+ // For the other half, create a context with a deadline instead. This is
+ // different because the context deadline is used to set the socket write
+ // deadline.
+ ctx, cancel = context.WithTimeout(context.Background(), timeout)
+ }
+
+ // Now perform a call with the context.
+ // The key thing here is that no call will ever complete successfully.
+ err := client.CallContext(ctx, nil, "test_block")
+ switch {
+ case err == nil:
+ _, hasDeadline := ctx.Deadline()
+ t.Errorf("no error for call with %v wait time (deadline: %v)", timeout, hasDeadline)
+ // default:
+ // t.Logf("got expected error with %v wait time: %v", timeout, err)
+ }
+ cancel()
+ }
+ }
+ wg.Add(ncallers)
+ for i := 0; i < ncallers; i++ {
+ go caller(i)
+ }
+ wg.Wait()
+}
+
+func TestClientSubscribeInvalidArg(t *testing.T) {
+ server := newTestServer()
+ defer server.Stop()
+ client := DialInProc(server)
+ defer client.Close()
+
+ check := func(shouldPanic bool, arg interface{}) {
+ defer func() {
+ err := recover()
+ if shouldPanic && err == nil {
+ t.Errorf("EthSubscribe should've panicked for %#v", arg)
+ }
+ if !shouldPanic && err != nil {
+ t.Errorf("EthSubscribe shouldn't have panicked for %#v", arg)
+ buf := make([]byte, 1024*1024)
+ buf = buf[:runtime.Stack(buf, false)]
+ t.Error(err)
+ t.Error(string(buf))
+ }
+ }()
+ client.EthSubscribe(context.Background(), arg, "foo_bar")
+ }
+ check(true, nil)
+ check(true, 1)
+ check(true, (chan int)(nil))
+ check(true, make(<-chan int))
+ check(false, make(chan int))
+ check(false, make(chan<- int))
+}
+
+func TestClientSubscribe(t *testing.T) {
+ server := newTestServer()
+ defer server.Stop()
+ client := DialInProc(server)
+ defer client.Close()
+
+ nc := make(chan int)
+ count := 10
+ sub, err := client.Subscribe(context.Background(), "nftest", nc, "someSubscription", count, 0)
+ if err != nil {
+ t.Fatal("can't subscribe:", err)
+ }
+ for i := 0; i < count; i++ {
+ if val := <-nc; val != i {
+ t.Fatalf("value mismatch: got %d, want %d", val, i)
+ }
+ }
+
+ sub.Unsubscribe()
+ select {
+ case v := <-nc:
+ t.Fatal("received value after unsubscribe:", v)
+ case err := <-sub.Err():
+ if err != nil {
+ t.Fatalf("Err returned a non-nil error after explicit unsubscribe: %q", err)
+ }
+ case <-time.After(1 * time.Second):
+ t.Fatalf("subscription not closed within 1s after unsubscribe")
+ }
+}
+
+// In this test, the connection drops while Subscribe is waiting for a response.
+func TestClientSubscribeClose(t *testing.T) {
+ server := newTestServer()
+ service := ¬ificationTestService{
+ gotHangSubscriptionReq: make(chan struct{}),
+ unblockHangSubscription: make(chan struct{}),
+ }
+ if err := server.RegisterName("nftest2", service); err != nil {
+ t.Fatal(err)
+ }
+
+ defer server.Stop()
+ client := DialInProc(server)
+ defer client.Close()
+
+ var (
+ nc = make(chan int)
+ errc = make(chan error, 1)
+ sub *ClientSubscription
+ err error
+ )
+ go func() {
+ sub, err = client.Subscribe(context.Background(), "nftest2", nc, "hangSubscription", 999)
+ errc <- err
+ }()
+
+ <-service.gotHangSubscriptionReq
+ client.Close()
+ service.unblockHangSubscription <- struct{}{}
+
+ select {
+ case err := <-errc:
+ if err == nil {
+ t.Errorf("Subscribe returned nil error after Close")
+ }
+ if sub != nil {
+ t.Error("Subscribe returned non-nil subscription after Close")
+ }
+ case <-time.After(1 * time.Second):
+ t.Fatalf("Subscribe did not return within 1s after Close")
+ }
+}
+
+// This test reproduces https://github.com/ethereum/go-ethereum/issues/17837 where the
+// client hangs during shutdown when Unsubscribe races with Client.Close.
+func TestClientCloseUnsubscribeRace(t *testing.T) {
+ server := newTestServer()
+ defer server.Stop()
+
+ for i := 0; i < 20; i++ {
+ client := DialInProc(server)
+ nc := make(chan int)
+ sub, err := client.Subscribe(context.Background(), "nftest", nc, "someSubscription", 3, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ go client.Close()
+ go sub.Unsubscribe()
+ select {
+ case <-sub.Err():
+ case <-time.After(5 * time.Second):
+ t.Fatal("subscription not closed within timeout")
+ }
+ }
+}
+
+// unsubscribeRecorder collects the subscription IDs of *_unsubscribe calls.
+type unsubscribeRecorder struct {
+ ServerCodec
+ unsubscribes map[string]bool
+}
+
+func (r *unsubscribeRecorder) readBatch() ([]*jsonrpcMessage, bool, error) {
+ if r.unsubscribes == nil {
+ r.unsubscribes = make(map[string]bool)
+ }
+
+ msgs, batch, err := r.ServerCodec.readBatch()
+ for _, msg := range msgs {
+ if msg.isUnsubscribe() {
+ var params []string
+ if err := json.Unmarshal(msg.Params, ¶ms); err != nil {
+ panic("unsubscribe decode error: " + err.Error())
+ }
+ r.unsubscribes[params[0]] = true
+ }
+ }
+ return msgs, batch, err
+}
+
+// This checks that Client calls the _unsubscribe method on the server when Unsubscribe is
+// called on a subscription.
+func TestClientSubscriptionUnsubscribeServer(t *testing.T) {
+ t.Parallel()
+
+ // Create the server.
+ srv := NewServer()
+ srv.RegisterName("nftest", new(notificationTestService))
+ p1, p2 := net.Pipe()
+ recorder := &unsubscribeRecorder{ServerCodec: NewCodec(p1)}
+ go srv.ServeCodec(recorder, OptionMethodInvocation|OptionSubscriptions)
+ defer srv.Stop()
+
+ // Create the client on the other end of the pipe.
+ client, _ := newClient(context.Background(), func(context.Context) (ServerCodec, error) {
+ return NewCodec(p2), nil
+ })
+ defer client.Close()
+
+ // Create the subscription.
+ ch := make(chan int)
+ sub, err := client.Subscribe(context.Background(), "nftest", ch, "someSubscription", 1, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ // Unsubscribe and check that unsubscribe was called.
+ sub.Unsubscribe()
+ if !recorder.unsubscribes[sub.subid] {
+ t.Fatal("client did not call unsubscribe method")
+ }
+ if _, open := <-sub.Err(); open {
+ t.Fatal("subscription error channel not closed after unsubscribe")
+ }
+}
+
+// This checks that the subscribed channel can be closed after Unsubscribe.
+// It is the reproducer for https://github.com/ethereum/go-ethereum/issues/22322
+func TestClientSubscriptionChannelClose(t *testing.T) {
+ t.Parallel()
+
+ var (
+ srv = NewServer()
+ httpsrv = httptest.NewServer(srv.WebsocketHandler(nil))
+ wsURL = "ws:" + strings.TrimPrefix(httpsrv.URL, "http:")
+ )
+ defer srv.Stop()
+ defer httpsrv.Close()
+
+ srv.RegisterName("nftest", new(notificationTestService))
+ client, _ := Dial(wsURL)
+
+ for i := 0; i < 100; i++ {
+ ch := make(chan int, 100)
+ sub, err := client.Subscribe(context.Background(), "nftest", ch, "someSubscription", maxClientSubscriptionBuffer-1, 1)
+ if err != nil {
+ t.Fatal(err)
+ }
+ sub.Unsubscribe()
+ close(ch)
+ }
+}
+
+// This test checks that Client doesn't lock up when a single subscriber
+// doesn't read subscription events.
+func TestClientNotificationStorm(t *testing.T) {
+ server := newTestServer()
+ defer server.Stop()
+
+ doTest := func(count int, wantError bool) {
+ client := DialInProc(server)
+ defer client.Close()
+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+ defer cancel()
+
+ // Subscribe on the server. It will start sending many notifications
+ // very quickly.
+ nc := make(chan int)
+ sub, err := client.Subscribe(ctx, "nftest", nc, "someSubscription", count, 0)
+ if err != nil {
+ t.Fatal("can't subscribe:", err)
+ }
+ defer sub.Unsubscribe()
+
+ // Process each notification, try to run a call in between each of them.
+ for i := 0; i < count; i++ {
+ select {
+ case val := <-nc:
+ if val != i {
+ t.Fatalf("(%d/%d) unexpected value %d", i, count, val)
+ }
+ case err := <-sub.Err():
+ if wantError && err != ErrSubscriptionQueueOverflow {
+ t.Fatalf("(%d/%d) got error %q, want %q", i, count, err, ErrSubscriptionQueueOverflow)
+ } else if !wantError {
+ t.Fatalf("(%d/%d) got unexpected error %q", i, count, err)
+ }
+ return
+ }
+ var r int
+ err := client.CallContext(ctx, &r, "nftest_echo", i)
+ if err != nil {
+ if !wantError {
+ t.Fatalf("(%d/%d) call error: %v", i, count, err)
+ }
+ return
+ }
+ }
+ if wantError {
+ t.Fatalf("didn't get expected error")
+ }
+ }
+
+ doTest(8000, false)
+ doTest(24000, true)
+}
+
+func TestClientSetHeader(t *testing.T) {
+ var gotHeader bool
+ srv := newTestServer()
+ httpsrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.Header.Get("test") == "ok" {
+ gotHeader = true
+ }
+ srv.ServeHTTP(w, r)
+ }))
+ defer httpsrv.Close()
+ defer srv.Stop()
+
+ client, err := Dial(httpsrv.URL)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer client.Close()
+
+ client.SetHeader("test", "ok")
+ if _, err := client.SupportedModules(); err != nil {
+ t.Fatal(err)
+ }
+ if !gotHeader {
+ t.Fatal("client did not set custom header")
+ }
+
+ // Check that Content-Type can be replaced.
+ client.SetHeader("content-type", "application/x-garbage")
+ _, err = client.SupportedModules()
+ if err == nil {
+ t.Fatal("no error for invalid content-type header")
+ } else if !strings.Contains(err.Error(), "Unsupported Media Type") {
+ t.Fatalf("error is not related to content-type: %q", err)
+ }
+}
+
+func TestClientHTTP(t *testing.T) {
+ server := newTestServer()
+ defer server.Stop()
+
+ client, hs := httpTestClient(server, "http", nil)
+ defer hs.Close()
+ defer client.Close()
+
+ // Launch concurrent requests.
+ var (
+ results = make([]echoResult, 100)
+ errc = make(chan error, len(results))
+ wantResult = echoResult{"a", 1, new(echoArgs)}
+ )
+ defer client.Close()
+ for i := range results {
+ i := i
+ go func() {
+ errc <- client.Call(&results[i], "test_echo", wantResult.String, wantResult.Int, wantResult.Args)
+ }()
+ }
+
+ // Wait for all of them to complete.
+ timeout := time.NewTimer(5 * time.Second)
+ defer timeout.Stop()
+ for i := range results {
+ select {
+ case err := <-errc:
+ if err != nil {
+ t.Fatal(err)
+ }
+ case <-timeout.C:
+ t.Fatalf("timeout (got %d/%d) results)", i+1, len(results))
+ }
+ }
+
+ // Check results.
+ for i := range results {
+ if !reflect.DeepEqual(results[i], wantResult) {
+ t.Errorf("result %d mismatch: got %#v, want %#v", i, results[i], wantResult)
+ }
+ }
+}
+
+func TestClientReconnect(t *testing.T) {
+ startServer := func(addr string) (*Server, net.Listener) {
+ srv := newTestServer()
+ l, err := net.Listen("tcp", addr)
+ if err != nil {
+ t.Fatal("can't listen:", err)
+ }
+ go http.Serve(l, srv.WebsocketHandler([]string{"*"}))
+ return srv, l
+ }
+
+ ctx, cancel := context.WithTimeout(context.Background(), 12*time.Second)
+ defer cancel()
+
+ // Start a server and corresponding client.
+ s1, l1 := startServer("127.0.0.1:0")
+ client, err := DialContext(ctx, "ws://"+l1.Addr().String())
+ defer client.Close()
+ if err != nil {
+ t.Fatal("can't dial", err)
+ }
+
+ // Perform a call. This should work because the server is up.
+ var resp echoResult
+ if err := client.CallContext(ctx, &resp, "test_echo", "", 1, nil); err != nil {
+ t.Fatal(err)
+ }
+
+ // Shut down the server and allow for some cool down time so we can listen on the same
+ // address again.
+ l1.Close()
+ s1.Stop()
+ time.Sleep(2 * time.Second)
+
+ // Try calling again. It shouldn't work.
+ if err := client.CallContext(ctx, &resp, "test_echo", "", 2, nil); err == nil {
+ t.Error("successful call while the server is down")
+ t.Logf("resp: %#v", resp)
+ }
+
+ // Start it up again and call again. The connection should be reestablished.
+ // We spawn multiple calls here to check whether this hangs somehow.
+ s2, l2 := startServer(l1.Addr().String())
+ defer l2.Close()
+ defer s2.Stop()
+
+ start := make(chan struct{})
+ errors := make(chan error, 20)
+ for i := 0; i < cap(errors); i++ {
+ go func() {
+ <-start
+ var resp echoResult
+ errors <- client.CallContext(ctx, &resp, "test_echo", "", 3, nil)
+ }()
+ }
+ close(start)
+ errcount := 0
+ for i := 0; i < cap(errors); i++ {
+ if err = <-errors; err != nil {
+ errcount++
+ }
+ }
+ t.Logf("%d errors, last error: %v", errcount, err)
+ if errcount > 1 {
+ t.Errorf("expected one error after disconnect, got %d", errcount)
+ }
+}
+
+func httpTestClient(srv *Server, transport string, fl *flakeyListener) (*Client, *httptest.Server) {
+ // Create the HTTP server.
+ var hs *httptest.Server
+ switch transport {
+ case "ws":
+ hs = httptest.NewUnstartedServer(srv.WebsocketHandler([]string{"*"}))
+ case "http":
+ hs = httptest.NewUnstartedServer(srv)
+ default:
+ panic("unknown HTTP transport: " + transport)
+ }
+ // Wrap the listener if required.
+ if fl != nil {
+ fl.Listener = hs.Listener
+ hs.Listener = fl
+ }
+ // Connect the client.
+ hs.Start()
+ client, err := Dial(transport + "://" + hs.Listener.Addr().String())
+ if err != nil {
+ panic(err)
+ }
+ return client, hs
+}
+
+func ipcTestClient(srv *Server, fl *flakeyListener) (*Client, net.Listener) {
+ // Listen on a random endpoint.
+ endpoint := fmt.Sprintf("go-ethereum-test-ipc-%d-%d", os.Getpid(), rand.Int63())
+ if runtime.GOOS == "windows" {
+ endpoint = `\\.\pipe\` + endpoint
+ } else {
+ endpoint = os.TempDir() + "/" + endpoint
+ }
+ l, err := ipcListen(endpoint)
+ if err != nil {
+ panic(err)
+ }
+ // Connect the listener to the server.
+ if fl != nil {
+ fl.Listener = l
+ l = fl
+ }
+ go srv.ServeListener(l)
+ // Connect the client.
+ client, err := Dial(endpoint)
+ if err != nil {
+ panic(err)
+ }
+ return client, l
+}
+
+// flakeyListener kills accepted connections after a random timeout.
+type flakeyListener struct {
+ net.Listener
+ maxKillTimeout time.Duration
+ maxAcceptDelay time.Duration
+}
+
+func (l *flakeyListener) Accept() (net.Conn, error) {
+ delay := time.Duration(rand.Int63n(int64(l.maxAcceptDelay)))
+ time.Sleep(delay)
+
+ c, err := l.Listener.Accept()
+ if err == nil {
+ timeout := time.Duration(rand.Int63n(int64(l.maxKillTimeout)))
+ time.AfterFunc(timeout, func() {
+ log.Debug(fmt.Sprintf("killing conn %v after %v", c.LocalAddr(), timeout))
+ c.Close()
+ })
+ }
+ return c, err
+}
diff --git a/relayer/chainproxy/rpcclient/constants_unix.go b/relayer/chainproxy/rpcclient/constants_unix.go
new file mode 100755
index 0000000000..4daf912f83
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/constants_unix.go
@@ -0,0 +1,34 @@
+// Copyright 2019 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+//go:build darwin || dragonfly || freebsd || linux || nacl || netbsd || openbsd || solaris
+// +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris
+
+package rpcclient
+
+/*
+#include
+
+int max_socket_path_size() {
+struct sockaddr_un s;
+return sizeof(s.sun_path);
+}
+*/
+import "C"
+
+var (
+ max_path_size = C.max_socket_path_size()
+)
diff --git a/relayer/chainproxy/rpcclient/constants_unix_nocgo.go b/relayer/chainproxy/rpcclient/constants_unix_nocgo.go
new file mode 100755
index 0000000000..56bba040af
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/constants_unix_nocgo.go
@@ -0,0 +1,26 @@
+// Copyright 2019 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+//go:build !cgo && !windows
+// +build !cgo,!windows
+
+package rpcclient
+
+var (
+ // On Linux, sun_path is 108 bytes in size
+ // see http://man7.org/linux/man-pages/man7/unix.7.html
+ max_path_size = 108
+)
diff --git a/relayer/chainproxy/rpcclient/doc.go b/relayer/chainproxy/rpcclient/doc.go
new file mode 100755
index 0000000000..43fba2f873
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/doc.go
@@ -0,0 +1,110 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+/*
+
+package rpcclient implements bi-directional JSON-RPC 2.0 on multiple transports.
+
+It provides access to the exported methods of an object across a network or other I/O
+connection. After creating a server or client instance, objects can be registered to make
+them visible as 'services'. Exported methods that follow specific conventions can be
+called remotely. It also has support for the publish/subscribe pattern.
+
+RPC Methods
+
+Methods that satisfy the following criteria are made available for remote access:
+
+ - method must be exported
+ - method returns 0, 1 (response or error) or 2 (response and error) values
+
+An example method:
+
+ func (s *CalcService) Add(a, b int) (int, error)
+
+When the returned error isn't nil the returned integer is ignored and the error is sent
+back to the client. Otherwise the returned integer is sent back to the client.
+
+Optional arguments are supported by accepting pointer values as arguments. E.g. if we want
+to do the addition in an optional finite field we can accept a mod argument as pointer
+value.
+
+ func (s *CalcService) Add(a, b int, mod *int) (int, error)
+
+This RPC method can be called with 2 integers and a null value as third argument. In that
+case the mod argument will be nil. Or it can be called with 3 integers, in that case mod
+will be pointing to the given third argument. Since the optional argument is the last
+argument the RPC package will also accept 2 integers as arguments. It will pass the mod
+argument as nil to the RPC method.
+
+The server offers the ServeCodec method which accepts a ServerCodec instance. It will read
+requests from the codec, process the request and sends the response back to the client
+using the codec. The server can execute requests concurrently. Responses can be sent back
+to the client out of order.
+
+An example server which uses the JSON codec:
+
+ type CalculatorService struct {}
+
+ func (s *CalculatorService) Add(a, b int) int {
+ return a + b
+ }
+
+ func (s *CalculatorService) Div(a, b int) (int, error) {
+ if b == 0 {
+ return 0, errors.New("divide by zero")
+ }
+ return a/b, nil
+ }
+
+ calculator := new(CalculatorService)
+ server := NewServer()
+ server.RegisterName("calculator", calculator)
+ l, _ := net.ListenUnix("unix", &net.UnixAddr{Net: "unix", Name: "/tmp/calculator.sock"})
+ server.ServeListener(l)
+
+Subscriptions
+
+The package also supports the publish subscribe pattern through the use of subscriptions.
+A method that is considered eligible for notifications must satisfy the following
+criteria:
+
+ - method must be exported
+ - first method argument type must be context.Context
+ - method must have return types (rpc.Subscription, error)
+
+An example method:
+
+ func (s *BlockChainService) NewBlocks(ctx context.Context) (rpc.Subscription, error) {
+ ...
+ }
+
+When the service containing the subscription method is registered to the server, for
+example under the "blockchain" namespace, a subscription is created by calling the
+"blockchain_subscribe" method.
+
+Subscriptions are deleted when the user sends an unsubscribe request or when the
+connection which was used to create the subscription is closed. This can be initiated by
+the client and server. The server will close the connection for any write error.
+
+For more information about subscriptions, see https://github.com/ethereum/go-ethereum/wiki/RPC-PUB-SUB.
+
+Reverse Calls
+
+In any method handler, an instance of rpc.Client can be accessed through the
+ClientFromContext method. Using this client instance, server-to-client method calls can be
+performed on the RPC connection.
+*/
+package rpcclient
diff --git a/relayer/chainproxy/rpcclient/endpoints.go b/relayer/chainproxy/rpcclient/endpoints.go
new file mode 100755
index 0000000000..e84e376b74
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/endpoints.go
@@ -0,0 +1,52 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "net"
+ "strings"
+
+ "github.com/ethereum/go-ethereum/log"
+)
+
+// StartIPCEndpoint starts an IPC endpoint.
+func StartIPCEndpoint(ipcEndpoint string, apis []API) (net.Listener, *Server, error) {
+ // Register all the APIs exposed by the services.
+ var (
+ handler = NewServer()
+ regMap = make(map[string]struct{})
+ registered []string
+ )
+ for _, api := range apis {
+ if err := handler.RegisterName(api.Namespace, api.Service); err != nil {
+ log.Info("IPC registration failed", "namespace", api.Namespace, "error", err)
+ return nil, nil, err
+ }
+ if _, ok := regMap[api.Namespace]; !ok {
+ registered = append(registered, api.Namespace)
+ regMap[api.Namespace] = struct{}{}
+ }
+ }
+ log.Debug("IPCs registered", "namespaces", strings.Join(registered, ","))
+ // All APIs registered, start the IPC listener.
+ listener, err := ipcListen(ipcEndpoint)
+ if err != nil {
+ return nil, nil, err
+ }
+ go handler.ServeListener(listener)
+ return listener, handler, nil
+}
diff --git a/relayer/chainproxy/rpcclient/errors.go b/relayer/chainproxy/rpcclient/errors.go
new file mode 100755
index 0000000000..ff3b344f99
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/errors.go
@@ -0,0 +1,103 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import "fmt"
+
+// HTTPError is returned by client operations when the HTTP status code of the
+// response is not a 2xx status.
+type HTTPError struct {
+ StatusCode int
+ Status string
+ Body []byte
+}
+
+func (err HTTPError) Error() string {
+ if len(err.Body) == 0 {
+ return err.Status
+ }
+ return fmt.Sprintf("%v: %s", err.Status, err.Body)
+}
+
+// Error wraps RPC errors, which contain an error code in addition to the message.
+type Error interface {
+ Error() string // returns the message
+ ErrorCode() int // returns the code
+}
+
+// A DataError contains some data in addition to the error message.
+type DataError interface {
+ Error() string // returns the message
+ ErrorData() interface{} // returns the error data
+}
+
+// Error types defined below are the built-in JSON-RPC errors.
+
+var (
+ _ Error = new(methodNotFoundError)
+ _ Error = new(subscriptionNotFoundError)
+ _ Error = new(parseError)
+ _ Error = new(invalidRequestError)
+ _ Error = new(invalidMessageError)
+ _ Error = new(invalidParamsError)
+)
+
+const defaultErrorCode = -32000
+
+type methodNotFoundError struct{ method string }
+
+func (e *methodNotFoundError) ErrorCode() int { return -32601 }
+
+func (e *methodNotFoundError) Error() string {
+ return fmt.Sprintf("the method %s does not exist/is not available", e.method)
+}
+
+type subscriptionNotFoundError struct{ namespace, subscription string }
+
+func (e *subscriptionNotFoundError) ErrorCode() int { return -32601 }
+
+func (e *subscriptionNotFoundError) Error() string {
+ return fmt.Sprintf("no %q subscription in %s namespace", e.subscription, e.namespace)
+}
+
+// Invalid JSON was received by the server.
+type parseError struct{ message string }
+
+func (e *parseError) ErrorCode() int { return -32700 }
+
+func (e *parseError) Error() string { return e.message }
+
+// received message isn't a valid request
+type invalidRequestError struct{ message string }
+
+func (e *invalidRequestError) ErrorCode() int { return -32600 }
+
+func (e *invalidRequestError) Error() string { return e.message }
+
+// received message is invalid
+type invalidMessageError struct{ message string }
+
+func (e *invalidMessageError) ErrorCode() int { return -32700 }
+
+func (e *invalidMessageError) Error() string { return e.message }
+
+// unable to decode supplied params, or an invalid number of parameters
+type invalidParamsError struct{ message string }
+
+func (e *invalidParamsError) ErrorCode() int { return -32602 }
+
+func (e *invalidParamsError) Error() string { return e.message }
diff --git a/relayer/chainproxy/rpcclient/handler.go b/relayer/chainproxy/rpcclient/handler.go
new file mode 100755
index 0000000000..40a3d37616
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/handler.go
@@ -0,0 +1,417 @@
+// Copyright 2019 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "context"
+ "encoding/json"
+ "reflect"
+ "strconv"
+ "strings"
+ "sync"
+ "time"
+
+ "github.com/ethereum/go-ethereum/log"
+)
+
+// handler handles JSON-RPC messages. There is one handler per connection. Note that
+// handler is not safe for concurrent use. Message handling never blocks indefinitely
+// because RPCs are processed on background goroutines launched by handler.
+//
+// The entry points for incoming messages are:
+//
+// h.handleMsg(message)
+// h.handleBatch(message)
+//
+// Outgoing calls use the requestOp struct. Register the request before sending it
+// on the connection:
+//
+// op := &requestOp{ids: ...}
+// h.addRequestOp(op)
+//
+// Now send the request, then wait for the reply to be delivered through handleMsg:
+//
+// if err := op.wait(...); err != nil {
+// h.removeRequestOp(op) // timeout, etc.
+// }
+//
+type handler struct {
+ reg *serviceRegistry
+ unsubscribeCb *callback
+ idgen func() ID // subscription ID generator
+ respWait map[string]*requestOp // active client requests
+ clientSubs map[string]*ClientSubscription // active client subscriptions
+ callWG sync.WaitGroup // pending call goroutines
+ rootCtx context.Context // canceled by close()
+ cancelRoot func() // cancel function for rootCtx
+ conn jsonWriter // where responses will be sent
+ log log.Logger
+ allowSubscribe bool
+
+ subLock sync.Mutex
+ serverSubs map[ID]*Subscription
+}
+
+type callProc struct {
+ ctx context.Context
+ notifiers []*Notifier
+}
+
+func newHandler(connCtx context.Context, conn jsonWriter, idgen func() ID, reg *serviceRegistry) *handler {
+ rootCtx, cancelRoot := context.WithCancel(connCtx)
+ h := &handler{
+ reg: reg,
+ idgen: idgen,
+ conn: conn,
+ respWait: make(map[string]*requestOp),
+ clientSubs: make(map[string]*ClientSubscription),
+ rootCtx: rootCtx,
+ cancelRoot: cancelRoot,
+ allowSubscribe: true,
+ serverSubs: make(map[ID]*Subscription),
+ log: log.Root(),
+ }
+ if conn.remoteAddr() != "" {
+ h.log = h.log.New("conn", conn.remoteAddr())
+ }
+ h.unsubscribeCb = newCallback(reflect.Value{}, reflect.ValueOf(h.unsubscribe))
+ return h
+}
+
+// handleBatch executes all messages in a batch and returns the responses.
+func (h *handler) handleBatch(msgs []*jsonrpcMessage) {
+ // Emit error response for empty batches:
+ if len(msgs) == 0 {
+ h.startCallProc(func(cp *callProc) {
+ h.conn.writeJSON(cp.ctx, errorMessage(&invalidRequestError{"empty batch"}))
+ })
+ return
+ }
+
+ // Handle non-call messages first:
+ calls := make([]*jsonrpcMessage, 0, len(msgs))
+ for _, msg := range msgs {
+ if handled := h.handleImmediate(msg); !handled {
+ calls = append(calls, msg)
+ }
+ }
+ if len(calls) == 0 {
+ return
+ }
+ // Process calls on a goroutine because they may block indefinitely:
+ h.startCallProc(func(cp *callProc) {
+ answers := make([]*jsonrpcMessage, 0, len(msgs))
+ for _, msg := range calls {
+ if answer := h.handleCallMsg(cp, msg); answer != nil {
+ answers = append(answers, answer)
+ }
+ }
+ h.addSubscriptions(cp.notifiers)
+ if len(answers) > 0 {
+ h.conn.writeJSON(cp.ctx, answers)
+ }
+ for _, n := range cp.notifiers {
+ n.activate()
+ }
+ })
+}
+
+// handleMsg handles a single message.
+func (h *handler) handleMsg(msg *jsonrpcMessage) {
+ if ok := h.handleImmediate(msg); ok {
+ return
+ }
+ h.startCallProc(func(cp *callProc) {
+ answer := h.handleCallMsg(cp, msg)
+ h.addSubscriptions(cp.notifiers)
+ if answer != nil {
+ h.conn.writeJSON(cp.ctx, answer)
+ }
+ for _, n := range cp.notifiers {
+ n.activate()
+ }
+ })
+}
+
+// close cancels all requests except for inflightReq and waits for
+// call goroutines to shut down.
+func (h *handler) close(err error, inflightReq *requestOp) {
+ h.cancelAllRequests(err, inflightReq)
+ h.callWG.Wait()
+ h.cancelRoot()
+ h.cancelServerSubscriptions(err)
+}
+
+// addRequestOp registers a request operation.
+func (h *handler) addRequestOp(op *requestOp) {
+ for _, id := range op.ids {
+ h.respWait[string(id)] = op
+ }
+}
+
+// removeRequestOps stops waiting for the given request IDs.
+func (h *handler) removeRequestOp(op *requestOp) {
+ for _, id := range op.ids {
+ delete(h.respWait, string(id))
+ }
+}
+
+// cancelAllRequests unblocks and removes pending requests and active subscriptions.
+func (h *handler) cancelAllRequests(err error, inflightReq *requestOp) {
+ didClose := make(map[*requestOp]bool)
+ if inflightReq != nil {
+ didClose[inflightReq] = true
+ }
+
+ for id, op := range h.respWait {
+ // Remove the op so that later calls will not close op.resp again.
+ delete(h.respWait, id)
+
+ if !didClose[op] {
+ op.err = err
+ close(op.resp)
+ didClose[op] = true
+ }
+ }
+ for id, sub := range h.clientSubs {
+ delete(h.clientSubs, id)
+ sub.close(err)
+ }
+}
+
+func (h *handler) addSubscriptions(nn []*Notifier) {
+ h.subLock.Lock()
+ defer h.subLock.Unlock()
+
+ for _, n := range nn {
+ if sub := n.takeSubscription(); sub != nil {
+ h.serverSubs[sub.ID] = sub
+ }
+ }
+}
+
+// cancelServerSubscriptions removes all subscriptions and closes their error channels.
+func (h *handler) cancelServerSubscriptions(err error) {
+ h.subLock.Lock()
+ defer h.subLock.Unlock()
+
+ for id, s := range h.serverSubs {
+ s.err <- err
+ close(s.err)
+ delete(h.serverSubs, id)
+ }
+}
+
+// startCallProc runs fn in a new goroutine and starts tracking it in the h.calls wait group.
+func (h *handler) startCallProc(fn func(*callProc)) {
+ h.callWG.Add(1)
+ go func() {
+ ctx, cancel := context.WithCancel(h.rootCtx)
+ defer h.callWG.Done()
+ defer cancel()
+ fn(&callProc{ctx: ctx})
+ }()
+}
+
+// handleImmediate executes non-call messages. It returns false if the message is a
+// call or requires a reply.
+func (h *handler) handleImmediate(msg *jsonrpcMessage) bool {
+ start := time.Now()
+ switch {
+ case msg.isNotification():
+ if strings.HasSuffix(msg.Method, notificationMethodSuffix) {
+ h.handleSubscriptionResult(msg)
+ return true
+ }
+ return false
+ case msg.isResponse():
+ h.handleResponse(msg)
+ h.log.Trace("Handled RPC response", "reqid", idForLog{msg.ID}, "duration", time.Since(start))
+ return true
+ default:
+ return false
+ }
+}
+
+// handleSubscriptionResult processes subscription notifications.
+func (h *handler) handleSubscriptionResult(msg *jsonrpcMessage) {
+ var result subscriptionResult
+ if err := json.Unmarshal(msg.Params, &result); err != nil {
+ h.log.Debug("Dropping invalid subscription message")
+ return
+ }
+ if h.clientSubs[result.ID] != nil {
+ h.clientSubs[result.ID].deliver(result.Result)
+ }
+}
+
+// handleResponse processes method call responses.
+func (h *handler) handleResponse(msg *jsonrpcMessage) {
+ op := h.respWait[string(msg.ID)]
+ if op == nil {
+ h.log.Debug("Unsolicited RPC response", "reqid", idForLog{msg.ID})
+ return
+ }
+ delete(h.respWait, string(msg.ID))
+ // For normal responses, just forward the reply to Call/BatchCall.
+ if op.sub == nil {
+ op.resp <- msg
+ return
+ }
+ // For subscription responses, start the subscription if the server
+ // indicates success. EthSubscribe gets unblocked in either case through
+ // the op.resp channel.
+ defer close(op.resp)
+ if msg.Error != nil {
+ op.err = msg.Error
+ return
+ }
+ if op.err = json.Unmarshal(msg.Result, &op.sub.subid); op.err == nil {
+ go op.sub.run()
+ h.clientSubs[op.sub.subid] = op.sub
+ }
+}
+
+// handleCallMsg executes a call message and returns the answer.
+func (h *handler) handleCallMsg(ctx *callProc, msg *jsonrpcMessage) *jsonrpcMessage {
+ start := time.Now()
+ switch {
+ case msg.isNotification():
+ h.handleCall(ctx, msg)
+ h.log.Debug("Served "+msg.Method, "duration", time.Since(start))
+ return nil
+ case msg.isCall():
+ resp := h.handleCall(ctx, msg)
+ var ctx []interface{}
+ ctx = append(ctx, "reqid", idForLog{msg.ID}, "duration", time.Since(start))
+ if resp.Error != nil {
+ ctx = append(ctx, "err", resp.Error.Message)
+ if resp.Error.Data != nil {
+ ctx = append(ctx, "errdata", resp.Error.Data)
+ }
+ h.log.Warn("Served "+msg.Method, ctx...)
+ } else {
+ h.log.Debug("Served "+msg.Method, ctx...)
+ }
+ return resp
+ case msg.hasValidID():
+ return msg.errorResponse(&invalidRequestError{"invalid request"})
+ default:
+ return errorMessage(&invalidRequestError{"invalid request"})
+ }
+}
+
+// handleCall processes method calls.
+func (h *handler) handleCall(cp *callProc, msg *jsonrpcMessage) *jsonrpcMessage {
+ if msg.isSubscribe() {
+ return h.handleSubscribe(cp, msg)
+ }
+ var callb *callback
+ if msg.isUnsubscribe() {
+ callb = h.unsubscribeCb
+ } else {
+ callb = h.reg.callback(msg.Method)
+ }
+ if callb == nil {
+ return msg.errorResponse(&methodNotFoundError{method: msg.Method})
+ }
+ args, err := parsePositionalArguments(msg.Params, callb.argTypes)
+ if err != nil {
+ return msg.errorResponse(&invalidParamsError{err.Error()})
+ }
+ start := time.Now()
+ answer := h.runMethod(cp.ctx, msg, callb, args)
+
+ // Collect the statistics for RPC calls if metrics is enabled.
+ // We only care about pure rpc call. Filter out subscription.
+ if callb != h.unsubscribeCb {
+ rpcRequestGauge.Inc(1)
+ if answer.Error != nil {
+ failedRequestGauge.Inc(1)
+ } else {
+ successfulRequestGauge.Inc(1)
+ }
+ rpcServingTimer.UpdateSince(start)
+ newRPCServingTimer(msg.Method, answer.Error == nil).UpdateSince(start)
+ }
+ return answer
+}
+
+// handleSubscribe processes *_subscribe method calls.
+func (h *handler) handleSubscribe(cp *callProc, msg *jsonrpcMessage) *jsonrpcMessage {
+ if !h.allowSubscribe {
+ return msg.errorResponse(ErrNotificationsUnsupported)
+ }
+
+ // Subscription method name is first argument.
+ name, err := parseSubscriptionName(msg.Params)
+ if err != nil {
+ return msg.errorResponse(&invalidParamsError{err.Error()})
+ }
+ namespace := msg.namespace()
+ callb := h.reg.subscription(namespace, name)
+ if callb == nil {
+ return msg.errorResponse(&subscriptionNotFoundError{namespace, name})
+ }
+
+ // Parse subscription name arg too, but remove it before calling the callback.
+ argTypes := append([]reflect.Type{stringType}, callb.argTypes...)
+ args, err := parsePositionalArguments(msg.Params, argTypes)
+ if err != nil {
+ return msg.errorResponse(&invalidParamsError{err.Error()})
+ }
+ args = args[1:]
+
+ // Install notifier in context so the subscription handler can find it.
+ n := &Notifier{h: h, namespace: namespace}
+ cp.notifiers = append(cp.notifiers, n)
+ ctx := context.WithValue(cp.ctx, notifierKey{}, n)
+
+ return h.runMethod(ctx, msg, callb, args)
+}
+
+// runMethod runs the Go callback for an RPC method.
+func (h *handler) runMethod(ctx context.Context, msg *jsonrpcMessage, callb *callback, args []reflect.Value) *jsonrpcMessage {
+ result, err := callb.call(ctx, msg.Method, args)
+ if err != nil {
+ return msg.errorResponse(err)
+ }
+ return msg.response(result)
+}
+
+// unsubscribe is the callback function for all *_unsubscribe calls.
+func (h *handler) unsubscribe(ctx context.Context, id ID) (bool, error) {
+ h.subLock.Lock()
+ defer h.subLock.Unlock()
+
+ s := h.serverSubs[id]
+ if s == nil {
+ return false, ErrSubscriptionNotFound
+ }
+ close(s.err)
+ delete(h.serverSubs, id)
+ return true, nil
+}
+
+type idForLog struct{ json.RawMessage }
+
+func (id idForLog) String() string {
+ if s, err := strconv.Unquote(string(id.RawMessage)); err == nil {
+ return s
+ }
+ return string(id.RawMessage)
+}
diff --git a/relayer/chainproxy/rpcclient/http.go b/relayer/chainproxy/rpcclient/http.go
new file mode 100755
index 0000000000..50a927c6a5
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/http.go
@@ -0,0 +1,290 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io"
+ "mime"
+ "net/http"
+ "net/url"
+ "sync"
+ "time"
+)
+
+const (
+ maxRequestContentLength = 1024 * 1024 * 5
+ contentType = "application/json"
+)
+
+// https://www.jsonrpc.org/historical/json-rpc-over-http.html#id13
+var acceptedContentTypes = []string{contentType, "application/json-rpc", "application/jsonrequest"}
+
+type httpConn struct {
+ client *http.Client
+ url string
+ closeOnce sync.Once
+ closeCh chan interface{}
+ mu sync.Mutex // protects headers
+ headers http.Header
+}
+
+// httpConn implements ServerCodec, but it is treated specially by Client
+// and some methods don't work. The panic() stubs here exist to ensure
+// this special treatment is correct.
+
+func (hc *httpConn) writeJSON(context.Context, interface{}) error {
+ panic("writeJSON called on httpConn")
+}
+
+func (hc *httpConn) peerInfo() PeerInfo {
+ panic("peerInfo called on httpConn")
+}
+
+func (hc *httpConn) remoteAddr() string {
+ return hc.url
+}
+
+func (hc *httpConn) readBatch() ([]*jsonrpcMessage, bool, error) {
+ <-hc.closeCh
+ return nil, false, io.EOF
+}
+
+func (hc *httpConn) close() {
+ hc.closeOnce.Do(func() { close(hc.closeCh) })
+}
+
+func (hc *httpConn) closed() <-chan interface{} {
+ return hc.closeCh
+}
+
+// HTTPTimeouts represents the configuration params for the HTTP RPC server.
+type HTTPTimeouts struct {
+ // ReadTimeout is the maximum duration for reading the entire
+ // request, including the body.
+ //
+ // Because ReadTimeout does not let Handlers make per-request
+ // decisions on each request body's acceptable deadline or
+ // upload rate, most users will prefer to use
+ // ReadHeaderTimeout. It is valid to use them both.
+ ReadTimeout time.Duration
+
+ // WriteTimeout is the maximum duration before timing out
+ // writes of the response. It is reset whenever a new
+ // request's header is read. Like ReadTimeout, it does not
+ // let Handlers make decisions on a per-request basis.
+ WriteTimeout time.Duration
+
+ // IdleTimeout is the maximum amount of time to wait for the
+ // next request when keep-alives are enabled. If IdleTimeout
+ // is zero, the value of ReadTimeout is used. If both are
+ // zero, ReadHeaderTimeout is used.
+ IdleTimeout time.Duration
+}
+
+// DefaultHTTPTimeouts represents the default timeout values used if further
+// configuration is not provided.
+var DefaultHTTPTimeouts = HTTPTimeouts{
+ ReadTimeout: 30 * time.Second,
+ WriteTimeout: 30 * time.Second,
+ IdleTimeout: 120 * time.Second,
+}
+
+// DialHTTPWithClient creates a new RPC client that connects to an RPC server over HTTP
+// using the provided HTTP Client.
+func DialHTTPWithClient(endpoint string, client *http.Client) (*Client, error) {
+ // Sanity check URL so we don't end up with a client that will fail every request.
+ _, err := url.Parse(endpoint)
+ if err != nil {
+ return nil, err
+ }
+
+ initctx := context.Background()
+ headers := make(http.Header, 2)
+ headers.Set("accept", contentType)
+ headers.Set("content-type", contentType)
+ return newClient(initctx, func(context.Context) (ServerCodec, error) {
+ hc := &httpConn{
+ client: client,
+ headers: headers,
+ url: endpoint,
+ closeCh: make(chan interface{}),
+ }
+ return hc, nil
+ })
+}
+
+// DialHTTP creates a new RPC client that connects to an RPC server over HTTP.
+func DialHTTP(endpoint string) (*Client, error) {
+ return DialHTTPWithClient(endpoint, new(http.Client))
+}
+
+func (c *Client) sendHTTP(ctx context.Context, op *requestOp, msg interface{}) error {
+ hc := c.writeConn.(*httpConn)
+ respBody, err := hc.doRequest(ctx, msg)
+ if err != nil {
+ return err
+ }
+ defer respBody.Close()
+
+ var respmsg jsonrpcMessage
+ if err := json.NewDecoder(respBody).Decode(&respmsg); err != nil {
+ return err
+ }
+ op.resp <- &respmsg
+ return nil
+}
+
+func (c *Client) sendBatchHTTP(ctx context.Context, op *requestOp, msgs []*jsonrpcMessage) error {
+ hc := c.writeConn.(*httpConn)
+ respBody, err := hc.doRequest(ctx, msgs)
+ if err != nil {
+ return err
+ }
+ defer respBody.Close()
+ var respmsgs []jsonrpcMessage
+ if err := json.NewDecoder(respBody).Decode(&respmsgs); err != nil {
+ return err
+ }
+ for i := 0; i < len(respmsgs); i++ {
+ op.resp <- &respmsgs[i]
+ }
+ return nil
+}
+
+func (hc *httpConn) doRequest(ctx context.Context, msg interface{}) (io.ReadCloser, error) {
+ body, err := json.Marshal(msg)
+ if err != nil {
+ return nil, err
+ }
+ req, err := http.NewRequestWithContext(ctx, "POST", hc.url, io.NopCloser(bytes.NewReader(body)))
+ if err != nil {
+ return nil, err
+ }
+ req.ContentLength = int64(len(body))
+ req.GetBody = func() (io.ReadCloser, error) { return io.NopCloser(bytes.NewReader(body)), nil }
+
+ // set headers
+ hc.mu.Lock()
+ req.Header = hc.headers.Clone()
+ hc.mu.Unlock()
+
+ // do request
+ resp, err := hc.client.Do(req)
+ if err != nil {
+ return nil, err
+ }
+ if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+ var buf bytes.Buffer
+ var body []byte
+ if _, err := buf.ReadFrom(resp.Body); err == nil {
+ body = buf.Bytes()
+ }
+
+ return nil, HTTPError{
+ Status: resp.Status,
+ StatusCode: resp.StatusCode,
+ Body: body,
+ }
+ }
+ return resp.Body, nil
+}
+
+// httpServerConn turns a HTTP connection into a Conn.
+type httpServerConn struct {
+ io.Reader
+ io.Writer
+ r *http.Request
+}
+
+func newHTTPServerConn(r *http.Request, w http.ResponseWriter) ServerCodec {
+ body := io.LimitReader(r.Body, maxRequestContentLength)
+ conn := &httpServerConn{Reader: body, Writer: w, r: r}
+ return NewCodec(conn)
+}
+
+// Close does nothing and always returns nil.
+func (t *httpServerConn) Close() error { return nil }
+
+// RemoteAddr returns the peer address of the underlying connection.
+func (t *httpServerConn) RemoteAddr() string {
+ return t.r.RemoteAddr
+}
+
+// SetWriteDeadline does nothing and always returns nil.
+func (t *httpServerConn) SetWriteDeadline(time.Time) error { return nil }
+
+// ServeHTTP serves JSON-RPC requests over HTTP.
+func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+ // Permit dumb empty requests for remote health-checks (AWS)
+ if r.Method == http.MethodGet && r.ContentLength == 0 && r.URL.RawQuery == "" {
+ w.WriteHeader(http.StatusOK)
+ return
+ }
+ if code, err := validateRequest(r); err != nil {
+ http.Error(w, err.Error(), code)
+ return
+ }
+
+ // Create request-scoped context.
+ connInfo := PeerInfo{Transport: "http", RemoteAddr: r.RemoteAddr}
+ connInfo.HTTP.Version = r.Proto
+ connInfo.HTTP.Host = r.Host
+ connInfo.HTTP.Origin = r.Header.Get("Origin")
+ connInfo.HTTP.UserAgent = r.Header.Get("User-Agent")
+ ctx := r.Context()
+ ctx = context.WithValue(ctx, peerInfoContextKey{}, connInfo)
+
+ // All checks passed, create a codec that reads directly from the request body
+ // until EOF, writes the response to w, and orders the server to process a
+ // single request.
+ w.Header().Set("content-type", contentType)
+ codec := newHTTPServerConn(r, w)
+ defer codec.close()
+ s.serveSingleRequest(ctx, codec)
+}
+
+// validateRequest returns a non-zero response code and error message if the
+// request is invalid.
+func validateRequest(r *http.Request) (int, error) {
+ if r.Method == http.MethodPut || r.Method == http.MethodDelete {
+ return http.StatusMethodNotAllowed, errors.New("method not allowed")
+ }
+ if r.ContentLength > maxRequestContentLength {
+ err := fmt.Errorf("content length too large (%d>%d)", r.ContentLength, maxRequestContentLength)
+ return http.StatusRequestEntityTooLarge, err
+ }
+ // Allow OPTIONS (regardless of content-type)
+ if r.Method == http.MethodOptions {
+ return 0, nil
+ }
+ // Check content-type
+ if mt, _, err := mime.ParseMediaType(r.Header.Get("content-type")); err == nil {
+ for _, accepted := range acceptedContentTypes {
+ if accepted == mt {
+ return 0, nil
+ }
+ }
+ }
+ // Invalid content-type
+ err := fmt.Errorf("invalid content type, only %s is supported", contentType)
+ return http.StatusUnsupportedMediaType, err
+}
diff --git a/relayer/chainproxy/rpcclient/http_test.go b/relayer/chainproxy/rpcclient/http_test.go
new file mode 100755
index 0000000000..0ba25baa82
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/http_test.go
@@ -0,0 +1,200 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+)
+
+func confirmStatusCode(t *testing.T, got, want int) {
+ t.Helper()
+ if got == want {
+ return
+ }
+ if gotName := http.StatusText(got); len(gotName) > 0 {
+ if wantName := http.StatusText(want); len(wantName) > 0 {
+ t.Fatalf("response status code: got %d (%s), want %d (%s)", got, gotName, want, wantName)
+ }
+ }
+ t.Fatalf("response status code: got %d, want %d", got, want)
+}
+
+func confirmRequestValidationCode(t *testing.T, method, contentType, body string, expectedStatusCode int) {
+ t.Helper()
+ request := httptest.NewRequest(method, "http://url.com", strings.NewReader(body))
+ if len(contentType) > 0 {
+ request.Header.Set("Content-Type", contentType)
+ }
+ code, err := validateRequest(request)
+ if code == 0 {
+ if err != nil {
+ t.Errorf("validation: got error %v, expected nil", err)
+ }
+ } else if err == nil {
+ t.Errorf("validation: code %d: got nil, expected error", code)
+ }
+ confirmStatusCode(t, code, expectedStatusCode)
+}
+
+func TestHTTPErrorResponseWithDelete(t *testing.T) {
+ confirmRequestValidationCode(t, http.MethodDelete, contentType, "", http.StatusMethodNotAllowed)
+}
+
+func TestHTTPErrorResponseWithPut(t *testing.T) {
+ confirmRequestValidationCode(t, http.MethodPut, contentType, "", http.StatusMethodNotAllowed)
+}
+
+func TestHTTPErrorResponseWithMaxContentLength(t *testing.T) {
+ body := make([]rune, maxRequestContentLength+1)
+ confirmRequestValidationCode(t,
+ http.MethodPost, contentType, string(body), http.StatusRequestEntityTooLarge)
+}
+
+func TestHTTPErrorResponseWithEmptyContentType(t *testing.T) {
+ confirmRequestValidationCode(t, http.MethodPost, "", "", http.StatusUnsupportedMediaType)
+}
+
+func TestHTTPErrorResponseWithValidRequest(t *testing.T) {
+ confirmRequestValidationCode(t, http.MethodPost, contentType, "", 0)
+}
+
+func confirmHTTPRequestYieldsStatusCode(t *testing.T, method, contentType, body string, expectedStatusCode int) {
+ t.Helper()
+ s := Server{}
+ ts := httptest.NewServer(&s)
+ defer ts.Close()
+
+ request, err := http.NewRequest(method, ts.URL, strings.NewReader(body))
+ if err != nil {
+ t.Fatalf("failed to create a valid HTTP request: %v", err)
+ }
+ if len(contentType) > 0 {
+ request.Header.Set("Content-Type", contentType)
+ }
+ resp, err := http.DefaultClient.Do(request)
+ if err != nil {
+ t.Fatalf("request failed: %v", err)
+ }
+ confirmStatusCode(t, resp.StatusCode, expectedStatusCode)
+}
+
+func TestHTTPResponseWithEmptyGet(t *testing.T) {
+ confirmHTTPRequestYieldsStatusCode(t, http.MethodGet, "", "", http.StatusOK)
+}
+
+// This checks that maxRequestContentLength is not applied to the response of a request.
+func TestHTTPRespBodyUnlimited(t *testing.T) {
+ const respLength = maxRequestContentLength * 3
+
+ s := NewServer()
+ defer s.Stop()
+ s.RegisterName("test", largeRespService{respLength})
+ ts := httptest.NewServer(s)
+ defer ts.Close()
+
+ c, err := DialHTTP(ts.URL)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer c.Close()
+
+ var r string
+ if err := c.Call(&r, "test_largeResp"); err != nil {
+ t.Fatal(err)
+ }
+ if len(r) != respLength {
+ t.Fatalf("response has wrong length %d, want %d", len(r), respLength)
+ }
+}
+
+// Tests that an HTTP error results in an HTTPError instance
+// being returned with the expected attributes.
+func TestHTTPErrorResponse(t *testing.T) {
+ ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ http.Error(w, "error has occurred!", http.StatusTeapot)
+ }))
+ defer ts.Close()
+
+ c, err := DialHTTP(ts.URL)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ var r string
+ err = c.Call(&r, "test_method")
+ if err == nil {
+ t.Fatal("error was expected")
+ }
+
+ httpErr, ok := err.(HTTPError)
+ if !ok {
+ t.Fatalf("unexpected error type %T", err)
+ }
+
+ if httpErr.StatusCode != http.StatusTeapot {
+ t.Error("unexpected status code", httpErr.StatusCode)
+ }
+ if httpErr.Status != "418 I'm a teapot" {
+ t.Error("unexpected status text", httpErr.Status)
+ }
+ if body := string(httpErr.Body); body != "error has occurred!\n" {
+ t.Error("unexpected body", body)
+ }
+
+ if errMsg := httpErr.Error(); errMsg != "418 I'm a teapot: error has occurred!\n" {
+ t.Error("unexpected error message", errMsg)
+ }
+}
+
+func TestHTTPPeerInfo(t *testing.T) {
+ s := newTestServer()
+ defer s.Stop()
+ ts := httptest.NewServer(s)
+ defer ts.Close()
+
+ c, err := Dial(ts.URL)
+ if err != nil {
+ t.Fatal(err)
+ }
+ c.SetHeader("user-agent", "ua-testing")
+ c.SetHeader("origin", "origin.example.com")
+
+ // Request peer information.
+ var info PeerInfo
+ if err := c.Call(&info, "test_peerInfo"); err != nil {
+ t.Fatal(err)
+ }
+
+ if info.RemoteAddr == "" {
+ t.Error("RemoteAddr not set")
+ }
+ if info.Transport != "http" {
+ t.Errorf("wrong Transport %q", info.Transport)
+ }
+ if info.HTTP.Version != "HTTP/1.1" {
+ t.Errorf("wrong HTTP.Version %q", info.HTTP.Version)
+ }
+ if info.HTTP.UserAgent != "ua-testing" {
+ t.Errorf("wrong HTTP.UserAgent %q", info.HTTP.UserAgent)
+ }
+ if info.HTTP.Origin != "origin.example.com" {
+ t.Errorf("wrong HTTP.Origin %q", info.HTTP.UserAgent)
+ }
+}
diff --git a/relayer/chainproxy/rpcclient/inproc.go b/relayer/chainproxy/rpcclient/inproc.go
new file mode 100755
index 0000000000..bfc4966ba2
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/inproc.go
@@ -0,0 +1,33 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "context"
+ "net"
+)
+
+// DialInProc attaches an in-process connection to the given RPC server.
+func DialInProc(handler *Server) *Client {
+ initctx := context.Background()
+ c, _ := newClient(initctx, func(context.Context) (ServerCodec, error) {
+ p1, p2 := net.Pipe()
+ go handler.ServeCodec(NewCodec(p1), 0)
+ return NewCodec(p2), nil
+ })
+ return c
+}
diff --git a/relayer/chainproxy/rpcclient/ipc.go b/relayer/chainproxy/rpcclient/ipc.go
new file mode 100755
index 0000000000..74a2daa3dd
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/ipc.go
@@ -0,0 +1,56 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "context"
+ "net"
+
+ "github.com/ethereum/go-ethereum/log"
+ "github.com/ethereum/go-ethereum/p2p/netutil"
+)
+
+// ServeListener accepts connections on l, serving JSON-RPC on them.
+func (s *Server) ServeListener(l net.Listener) error {
+ for {
+ conn, err := l.Accept()
+ if netutil.IsTemporaryError(err) {
+ log.Warn("RPC accept error", "err", err)
+ continue
+ } else if err != nil {
+ return err
+ }
+ log.Trace("Accepted RPC connection", "conn", conn.RemoteAddr())
+ go s.ServeCodec(NewCodec(conn), 0)
+ }
+}
+
+// DialIPC create a new IPC client that connects to the given endpoint. On Unix it assumes
+// the endpoint is the full path to a unix socket, and Windows the endpoint is an
+// identifier for a named pipe.
+//
+// The context is used for the initial connection establishment. It does not
+// affect subsequent interactions with the client.
+func DialIPC(ctx context.Context, endpoint string) (*Client, error) {
+ return newClient(ctx, func(ctx context.Context) (ServerCodec, error) {
+ conn, err := newIPCConnection(ctx, endpoint)
+ if err != nil {
+ return nil, err
+ }
+ return NewCodec(conn), err
+ })
+}
diff --git a/relayer/chainproxy/rpcclient/ipc_js.go b/relayer/chainproxy/rpcclient/ipc_js.go
new file mode 100755
index 0000000000..cfb8cd223d
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/ipc_js.go
@@ -0,0 +1,38 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+//go:build js
+// +build js
+
+package rpcclient
+
+import (
+ "context"
+ "errors"
+ "net"
+)
+
+var errNotSupported = errors.New("rpc: not supported")
+
+// ipcListen will create a named pipe on the given endpoint.
+func ipcListen(endpoint string) (net.Listener, error) {
+ return nil, errNotSupported
+}
+
+// newIPCConnection will connect to a named pipe with the given endpoint as name.
+func newIPCConnection(ctx context.Context, endpoint string) (net.Conn, error) {
+ return nil, errNotSupported
+}
diff --git a/relayer/chainproxy/rpcclient/ipc_unix.go b/relayer/chainproxy/rpcclient/ipc_unix.go
new file mode 100755
index 0000000000..c7c8a354c9
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/ipc_unix.go
@@ -0,0 +1,55 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+//go:build darwin || dragonfly || freebsd || linux || nacl || netbsd || openbsd || solaris
+// +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris
+
+package rpcclient
+
+import (
+ "context"
+ "fmt"
+ "net"
+ "os"
+ "path/filepath"
+
+ "github.com/ethereum/go-ethereum/log"
+)
+
+// ipcListen will create a Unix socket on the given endpoint.
+func ipcListen(endpoint string) (net.Listener, error) {
+ if len(endpoint) > int(max_path_size) {
+ log.Warn(fmt.Sprintf("The ipc endpoint is longer than %d characters. ", max_path_size),
+ "endpoint", endpoint)
+ }
+
+ // Ensure the IPC path exists and remove any previous leftover
+ if err := os.MkdirAll(filepath.Dir(endpoint), 0751); err != nil {
+ return nil, err
+ }
+ os.Remove(endpoint)
+ l, err := net.Listen("unix", endpoint)
+ if err != nil {
+ return nil, err
+ }
+ os.Chmod(endpoint, 0600)
+ return l, nil
+}
+
+// newIPCConnection will connect to a Unix socket on the given endpoint.
+func newIPCConnection(ctx context.Context, endpoint string) (net.Conn, error) {
+ return new(net.Dialer).DialContext(ctx, "unix", endpoint)
+}
diff --git a/relayer/chainproxy/rpcclient/ipc_windows.go b/relayer/chainproxy/rpcclient/ipc_windows.go
new file mode 100755
index 0000000000..8cc3cf1744
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/ipc_windows.go
@@ -0,0 +1,49 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+//go:build windows
+// +build windows
+
+package rpcclient
+
+import (
+ "context"
+ "net"
+ "time"
+
+ "gopkg.in/natefinch/npipe.v2"
+)
+
+// This is used if the dialing context has no deadline. It is much smaller than the
+// defaultDialTimeout because named pipes are local and there is no need to wait so long.
+const defaultPipeDialTimeout = 2 * time.Second
+
+// ipcListen will create a named pipe on the given endpoint.
+func ipcListen(endpoint string) (net.Listener, error) {
+ return npipe.Listen(endpoint)
+}
+
+// newIPCConnection will connect to a named pipe with the given endpoint as name.
+func newIPCConnection(ctx context.Context, endpoint string) (net.Conn, error) {
+ timeout := defaultPipeDialTimeout
+ if deadline, ok := ctx.Deadline(); ok {
+ timeout = deadline.Sub(time.Now())
+ if timeout < 0 {
+ timeout = 0
+ }
+ }
+ return npipe.DialTimeout(endpoint, timeout)
+}
diff --git a/relayer/chainproxy/rpcclient/json.go b/relayer/chainproxy/rpcclient/json.go
new file mode 100755
index 0000000000..53b425d900
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/json.go
@@ -0,0 +1,347 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io"
+ "reflect"
+ "strings"
+ "sync"
+ "time"
+)
+
+const (
+ vsn = "2.0"
+ serviceMethodSeparator = "_"
+ subscribeMethodSuffix = "_subscribe"
+ unsubscribeMethodSuffix = "_unsubscribe"
+ notificationMethodSuffix = "_subscription"
+
+ defaultWriteTimeout = 10 * time.Second // used if context has no deadline
+)
+
+var null = json.RawMessage("null")
+
+type subscriptionResult struct {
+ ID string `json:"subscription"`
+ Result json.RawMessage `json:"result,omitempty"`
+}
+
+// A value of this type can a JSON-RPC request, notification, successful response or
+// error response. Which one it is depends on the fields.
+type jsonrpcMessage struct {
+ Version string `json:"jsonrpc,omitempty"`
+ ID json.RawMessage `json:"id,omitempty"`
+ Method string `json:"method,omitempty"`
+ Params json.RawMessage `json:"params,omitempty"`
+ Error *jsonError `json:"error,omitempty"`
+ Result json.RawMessage `json:"result,omitempty"`
+}
+
+func (msg *jsonrpcMessage) isNotification() bool {
+ return msg.ID == nil && msg.Method != ""
+}
+
+func (msg *jsonrpcMessage) isCall() bool {
+ return msg.hasValidID() && msg.Method != ""
+}
+
+func (msg *jsonrpcMessage) isResponse() bool {
+ return msg.hasValidID() && msg.Method == "" && msg.Params == nil && (msg.Result != nil || msg.Error != nil)
+}
+
+func (msg *jsonrpcMessage) hasValidID() bool {
+ return len(msg.ID) > 0 && msg.ID[0] != '{' && msg.ID[0] != '['
+}
+
+func (msg *jsonrpcMessage) isSubscribe() bool {
+ return strings.HasSuffix(msg.Method, subscribeMethodSuffix)
+}
+
+func (msg *jsonrpcMessage) isUnsubscribe() bool {
+ return strings.HasSuffix(msg.Method, unsubscribeMethodSuffix)
+}
+
+func (msg *jsonrpcMessage) namespace() string {
+ elem := strings.SplitN(msg.Method, serviceMethodSeparator, 2)
+ return elem[0]
+}
+
+func (msg *jsonrpcMessage) String() string {
+ b, _ := json.Marshal(msg)
+ return string(b)
+}
+
+func (msg *jsonrpcMessage) errorResponse(err error) *jsonrpcMessage {
+ resp := errorMessage(err)
+ resp.ID = msg.ID
+ return resp
+}
+
+func (msg *jsonrpcMessage) response(result interface{}) *jsonrpcMessage {
+ enc, err := json.Marshal(result)
+ if err != nil {
+ // TODO: wrap with 'internal server error'
+ return msg.errorResponse(err)
+ }
+ return &jsonrpcMessage{Version: vsn, ID: msg.ID, Result: enc}
+}
+
+func errorMessage(err error) *jsonrpcMessage {
+ msg := &jsonrpcMessage{Version: vsn, ID: null, Error: &jsonError{
+ Code: defaultErrorCode,
+ Message: err.Error(),
+ }}
+ ec, ok := err.(Error)
+ if ok {
+ msg.Error.Code = ec.ErrorCode()
+ }
+ de, ok := err.(DataError)
+ if ok {
+ msg.Error.Data = de.ErrorData()
+ }
+ return msg
+}
+
+type jsonError struct {
+ Code int `json:"code"`
+ Message string `json:"message"`
+ Data interface{} `json:"data,omitempty"`
+}
+
+func (err *jsonError) Error() string {
+ if err.Message == "" {
+ return fmt.Sprintf("json-rpc error %d", err.Code)
+ }
+ return err.Message
+}
+
+func (err *jsonError) ErrorCode() int {
+ return err.Code
+}
+
+func (err *jsonError) ErrorData() interface{} {
+ return err.Data
+}
+
+// Conn is a subset of the methods of net.Conn which are sufficient for ServerCodec.
+type Conn interface {
+ io.ReadWriteCloser
+ SetWriteDeadline(time.Time) error
+}
+
+type deadlineCloser interface {
+ io.Closer
+ SetWriteDeadline(time.Time) error
+}
+
+// ConnRemoteAddr wraps the RemoteAddr operation, which returns a description
+// of the peer address of a connection. If a Conn also implements ConnRemoteAddr, this
+// description is used in log messages.
+type ConnRemoteAddr interface {
+ RemoteAddr() string
+}
+
+// jsonCodec reads and writes JSON-RPC messages to the underlying connection. It also has
+// support for parsing arguments and serializing (result) objects.
+type jsonCodec struct {
+ remote string
+ closer sync.Once // close closed channel once
+ closeCh chan interface{} // closed on Close
+ decode func(v interface{}) error // decoder to allow multiple transports
+ encMu sync.Mutex // guards the encoder
+ encode func(v interface{}) error // encoder to allow multiple transports
+ conn deadlineCloser
+}
+
+// NewFuncCodec creates a codec which uses the given functions to read and write. If conn
+// implements ConnRemoteAddr, log messages will use it to include the remote address of
+// the connection.
+func NewFuncCodec(conn deadlineCloser, encode, decode func(v interface{}) error) ServerCodec {
+ codec := &jsonCodec{
+ closeCh: make(chan interface{}),
+ encode: encode,
+ decode: decode,
+ conn: conn,
+ }
+ if ra, ok := conn.(ConnRemoteAddr); ok {
+ codec.remote = ra.RemoteAddr()
+ }
+ return codec
+}
+
+// NewCodec creates a codec on the given connection. If conn implements ConnRemoteAddr, log
+// messages will use it to include the remote address of the connection.
+func NewCodec(conn Conn) ServerCodec {
+ enc := json.NewEncoder(conn)
+ dec := json.NewDecoder(conn)
+ dec.UseNumber()
+ return NewFuncCodec(conn, enc.Encode, dec.Decode)
+}
+
+func (c *jsonCodec) peerInfo() PeerInfo {
+ // This returns "ipc" because all other built-in transports have a separate codec type.
+ return PeerInfo{Transport: "ipc", RemoteAddr: c.remote}
+}
+
+func (c *jsonCodec) remoteAddr() string {
+ return c.remote
+}
+
+func (c *jsonCodec) readBatch() (messages []*jsonrpcMessage, batch bool, err error) {
+ // Decode the next JSON object in the input stream.
+ // This verifies basic syntax, etc.
+ var rawmsg json.RawMessage
+ if err := c.decode(&rawmsg); err != nil {
+ return nil, false, err
+ }
+ messages, batch = parseMessage(rawmsg)
+ for i, msg := range messages {
+ if msg == nil {
+ // Message is JSON 'null'. Replace with zero value so it
+ // will be treated like any other invalid message.
+ messages[i] = new(jsonrpcMessage)
+ }
+ }
+ return messages, batch, nil
+}
+
+func (c *jsonCodec) writeJSON(ctx context.Context, v interface{}) error {
+ c.encMu.Lock()
+ defer c.encMu.Unlock()
+
+ deadline, ok := ctx.Deadline()
+ if !ok {
+ deadline = time.Now().Add(defaultWriteTimeout)
+ }
+ c.conn.SetWriteDeadline(deadline)
+ return c.encode(v)
+}
+
+func (c *jsonCodec) close() {
+ c.closer.Do(func() {
+ close(c.closeCh)
+ c.conn.Close()
+ })
+}
+
+// Closed returns a channel which will be closed when Close is called
+func (c *jsonCodec) closed() <-chan interface{} {
+ return c.closeCh
+}
+
+// parseMessage parses raw bytes as a (batch of) JSON-RPC message(s). There are no error
+// checks in this function because the raw message has already been syntax-checked when it
+// is called. Any non-JSON-RPC messages in the input return the zero value of
+// jsonrpcMessage.
+func parseMessage(raw json.RawMessage) ([]*jsonrpcMessage, bool) {
+ if !isBatch(raw) {
+ msgs := []*jsonrpcMessage{{}}
+ json.Unmarshal(raw, &msgs[0])
+ return msgs, false
+ }
+ dec := json.NewDecoder(bytes.NewReader(raw))
+ dec.Token() // skip '['
+ var msgs []*jsonrpcMessage
+ for dec.More() {
+ msgs = append(msgs, new(jsonrpcMessage))
+ dec.Decode(&msgs[len(msgs)-1])
+ }
+ return msgs, true
+}
+
+// isBatch returns true when the first non-whitespace characters is '['
+func isBatch(raw json.RawMessage) bool {
+ for _, c := range raw {
+ // skip insignificant whitespace (http://www.ietf.org/rfc/rfc4627.txt)
+ if c == 0x20 || c == 0x09 || c == 0x0a || c == 0x0d {
+ continue
+ }
+ return c == '['
+ }
+ return false
+}
+
+// parsePositionalArguments tries to parse the given args to an array of values with the
+// given types. It returns the parsed values or an error when the args could not be
+// parsed. Missing optional arguments are returned as reflect.Zero values.
+func parsePositionalArguments(rawArgs json.RawMessage, types []reflect.Type) ([]reflect.Value, error) {
+ dec := json.NewDecoder(bytes.NewReader(rawArgs))
+ var args []reflect.Value
+ tok, err := dec.Token()
+ switch {
+ case err == io.EOF || tok == nil && err == nil:
+ // "params" is optional and may be empty. Also allow "params":null even though it's
+ // not in the spec because our own client used to send it.
+ case err != nil:
+ return nil, err
+ case tok == json.Delim('['):
+ // Read argument array.
+ if args, err = parseArgumentArray(dec, types); err != nil {
+ return nil, err
+ }
+ default:
+ return nil, errors.New("non-array args")
+ }
+ // Set any missing args to nil.
+ for i := len(args); i < len(types); i++ {
+ if types[i].Kind() != reflect.Ptr {
+ return nil, fmt.Errorf("missing value for required argument %d", i)
+ }
+ args = append(args, reflect.Zero(types[i]))
+ }
+ return args, nil
+}
+
+func parseArgumentArray(dec *json.Decoder, types []reflect.Type) ([]reflect.Value, error) {
+ args := make([]reflect.Value, 0, len(types))
+ for i := 0; dec.More(); i++ {
+ if i >= len(types) {
+ return args, fmt.Errorf("too many arguments, want at most %d", len(types))
+ }
+ argval := reflect.New(types[i])
+ if err := dec.Decode(argval.Interface()); err != nil {
+ return args, fmt.Errorf("invalid argument %d: %v", i, err)
+ }
+ if argval.IsNil() && types[i].Kind() != reflect.Ptr {
+ return args, fmt.Errorf("missing value for required argument %d", i)
+ }
+ args = append(args, argval.Elem())
+ }
+ // Read end of args array.
+ _, err := dec.Token()
+ return args, err
+}
+
+// parseSubscriptionName extracts the subscription name from an encoded argument array.
+func parseSubscriptionName(rawArgs json.RawMessage) (string, error) {
+ dec := json.NewDecoder(bytes.NewReader(rawArgs))
+ if tok, _ := dec.Token(); tok != json.Delim('[') {
+ return "", errors.New("non-array args")
+ }
+ v, _ := dec.Token()
+ method, ok := v.(string)
+ if !ok {
+ return "", errors.New("expected subscription name as first argument")
+ }
+ return method, nil
+}
diff --git a/relayer/chainproxy/rpcclient/metrics.go b/relayer/chainproxy/rpcclient/metrics.go
new file mode 100755
index 0000000000..9403259c52
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/metrics.go
@@ -0,0 +1,39 @@
+// Copyright 2020 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "fmt"
+
+ "github.com/ethereum/go-ethereum/metrics"
+)
+
+var (
+ rpcRequestGauge = metrics.NewRegisteredGauge("rpc/requests", nil)
+ successfulRequestGauge = metrics.NewRegisteredGauge("rpc/success", nil)
+ failedRequestGauge = metrics.NewRegisteredGauge("rpc/failure", nil)
+ rpcServingTimer = metrics.NewRegisteredTimer("rpc/duration/all", nil)
+)
+
+func newRPCServingTimer(method string, valid bool) metrics.Timer {
+ flag := "success"
+ if !valid {
+ flag = "failure"
+ }
+ m := fmt.Sprintf("rpc/duration/%s/%s", method, flag)
+ return metrics.GetOrRegisterTimer(m, nil)
+}
diff --git a/relayer/chainproxy/rpcclient/server.go b/relayer/chainproxy/rpcclient/server.go
new file mode 100755
index 0000000000..a4124282a5
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/server.go
@@ -0,0 +1,183 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "context"
+ "io"
+ "sync/atomic"
+
+ mapset "github.com/deckarep/golang-set"
+ "github.com/ethereum/go-ethereum/log"
+)
+
+const MetadataApi = "rpc"
+const EngineApi = "engine"
+
+// CodecOption specifies which type of messages a codec supports.
+//
+// Deprecated: this option is no longer honored by Server.
+type CodecOption int
+
+const (
+ // OptionMethodInvocation is an indication that the codec supports RPC method calls
+ OptionMethodInvocation CodecOption = 1 << iota
+
+ // OptionSubscriptions is an indication that the codec supports RPC notifications
+ OptionSubscriptions = 1 << iota // support pub sub
+)
+
+// Server is an RPC server.
+type Server struct {
+ services serviceRegistry
+ idgen func() ID
+ run int32
+ codecs mapset.Set
+}
+
+// NewServer creates a new server instance with no registered handlers.
+func NewServer() *Server {
+ server := &Server{idgen: randomIDGenerator(), codecs: mapset.NewSet(), run: 1}
+ // Register the default service providing meta information about the RPC service such
+ // as the services and methods it offers.
+ rpcService := &RPCService{server}
+ server.RegisterName(MetadataApi, rpcService)
+ return server
+}
+
+// RegisterName creates a service for the given receiver type under the given name. When no
+// methods on the given receiver match the criteria to be either a RPC method or a
+// subscription an error is returned. Otherwise a new service is created and added to the
+// service collection this server provides to clients.
+func (s *Server) RegisterName(name string, receiver interface{}) error {
+ return s.services.registerName(name, receiver)
+}
+
+// ServeCodec reads incoming requests from codec, calls the appropriate callback and writes
+// the response back using the given codec. It will block until the codec is closed or the
+// server is stopped. In either case the codec is closed.
+//
+// Note that codec options are no longer supported.
+func (s *Server) ServeCodec(codec ServerCodec, options CodecOption) {
+ defer codec.close()
+
+ // Don't serve if server is stopped.
+ if atomic.LoadInt32(&s.run) == 0 {
+ return
+ }
+
+ // Add the codec to the set so it can be closed by Stop.
+ s.codecs.Add(codec)
+ defer s.codecs.Remove(codec)
+
+ c := initClient(codec, s.idgen, &s.services)
+ <-codec.closed()
+ c.Close()
+}
+
+// serveSingleRequest reads and processes a single RPC request from the given codec. This
+// is used to serve HTTP connections. Subscriptions and reverse calls are not allowed in
+// this mode.
+func (s *Server) serveSingleRequest(ctx context.Context, codec ServerCodec) {
+ // Don't serve if server is stopped.
+ if atomic.LoadInt32(&s.run) == 0 {
+ return
+ }
+
+ h := newHandler(ctx, codec, s.idgen, &s.services)
+ h.allowSubscribe = false
+ defer h.close(io.EOF, nil)
+
+ reqs, batch, err := codec.readBatch()
+ if err != nil {
+ if err != io.EOF {
+ codec.writeJSON(ctx, errorMessage(&invalidMessageError{"parse error"}))
+ }
+ return
+ }
+ if batch {
+ h.handleBatch(reqs)
+ } else {
+ h.handleMsg(reqs[0])
+ }
+}
+
+// Stop stops reading new requests, waits for stopPendingRequestTimeout to allow pending
+// requests to finish, then closes all codecs which will cancel pending requests and
+// subscriptions.
+func (s *Server) Stop() {
+ if atomic.CompareAndSwapInt32(&s.run, 1, 0) {
+ log.Debug("RPC server shutting down")
+ s.codecs.Each(func(c interface{}) bool {
+ c.(ServerCodec).close()
+ return true
+ })
+ }
+}
+
+// RPCService gives meta information about the server.
+// e.g. gives information about the loaded modules.
+type RPCService struct {
+ server *Server
+}
+
+// Modules returns the list of RPC services with their version number
+func (s *RPCService) Modules() map[string]string {
+ s.server.services.mu.Lock()
+ defer s.server.services.mu.Unlock()
+
+ modules := make(map[string]string)
+ for name := range s.server.services.services {
+ modules[name] = "1.0"
+ }
+ return modules
+}
+
+// PeerInfo contains information about the remote end of the network connection.
+//
+// This is available within RPC method handlers through the context. Call
+// PeerInfoFromContext to get information about the client connection related to
+// the current method call.
+type PeerInfo struct {
+ // Transport is name of the protocol used by the client.
+ // This can be "http", "ws" or "ipc".
+ Transport string
+
+ // Address of client. This will usually contain the IP address and port.
+ RemoteAddr string
+
+ // Addditional information for HTTP and WebSocket connections.
+ HTTP struct {
+ // Protocol version, i.e. "HTTP/1.1". This is not set for WebSocket.
+ Version string
+ // Header values sent by the client.
+ UserAgent string
+ Origin string
+ Host string
+ }
+}
+
+type peerInfoContextKey struct{}
+
+// PeerInfoFromContext returns information about the client's network connection.
+// Use this with the context passed to RPC method handler functions.
+//
+// The zero value is returned if no connection info is present in ctx.
+func PeerInfoFromContext(ctx context.Context) PeerInfo {
+ info, _ := ctx.Value(peerInfoContextKey{}).(PeerInfo)
+ return info
+}
diff --git a/relayer/chainproxy/rpcclient/server_test.go b/relayer/chainproxy/rpcclient/server_test.go
new file mode 100755
index 0000000000..a2807852db
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/server_test.go
@@ -0,0 +1,154 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "bufio"
+ "bytes"
+ "io"
+ "net"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+ "time"
+)
+
+func TestServerRegisterName(t *testing.T) {
+ server := NewServer()
+ service := new(testService)
+
+ if err := server.RegisterName("test", service); err != nil {
+ t.Fatalf("%v", err)
+ }
+
+ if len(server.services.services) != 2 {
+ t.Fatalf("Expected 2 service entries, got %d", len(server.services.services))
+ }
+
+ svc, ok := server.services.services["test"]
+ if !ok {
+ t.Fatalf("Expected service calc to be registered")
+ }
+
+ wantCallbacks := 10
+ if len(svc.callbacks) != wantCallbacks {
+ t.Errorf("Expected %d callbacks for service 'service', got %d", wantCallbacks, len(svc.callbacks))
+ }
+}
+
+func TestServer(t *testing.T) {
+ files, err := os.ReadDir("testdata")
+ if err != nil {
+ t.Fatal("where'd my testdata go?")
+ }
+ for _, f := range files {
+ if f.IsDir() || strings.HasPrefix(f.Name(), ".") {
+ continue
+ }
+ path := filepath.Join("testdata", f.Name())
+ name := strings.TrimSuffix(f.Name(), filepath.Ext(f.Name()))
+ t.Run(name, func(t *testing.T) {
+ runTestScript(t, path)
+ })
+ }
+}
+
+func runTestScript(t *testing.T, file string) {
+ server := newTestServer()
+ content, err := os.ReadFile(file)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ clientConn, serverConn := net.Pipe()
+ defer clientConn.Close()
+ go server.ServeCodec(NewCodec(serverConn), 0)
+ readbuf := bufio.NewReader(clientConn)
+ for _, line := range strings.Split(string(content), "\n") {
+ line = strings.TrimSpace(line)
+ switch {
+ case len(line) == 0 || strings.HasPrefix(line, "//"):
+ // skip comments, blank lines
+ continue
+ case strings.HasPrefix(line, "--> "):
+ t.Log(line)
+ // write to connection
+ clientConn.SetWriteDeadline(time.Now().Add(5 * time.Second))
+ if _, err := io.WriteString(clientConn, line[4:]+"\n"); err != nil {
+ t.Fatalf("write error: %v", err)
+ }
+ case strings.HasPrefix(line, "<-- "):
+ t.Log(line)
+ want := line[4:]
+ // read line from connection and compare text
+ clientConn.SetReadDeadline(time.Now().Add(5 * time.Second))
+ sent, err := readbuf.ReadString('\n')
+ if err != nil {
+ t.Fatalf("read error: %v", err)
+ }
+ sent = strings.TrimRight(sent, "\r\n")
+ if sent != want {
+ t.Errorf("wrong line from server\ngot: %s\nwant: %s", sent, want)
+ }
+ default:
+ panic("invalid line in test script: " + line)
+ }
+ }
+}
+
+// This test checks that responses are delivered for very short-lived connections that
+// only carry a single request.
+func TestServerShortLivedConn(t *testing.T) {
+ server := newTestServer()
+ defer server.Stop()
+
+ listener, err := net.Listen("tcp", "127.0.0.1:0")
+ if err != nil {
+ t.Fatal("can't listen:", err)
+ }
+ defer listener.Close()
+ go server.ServeListener(listener)
+
+ var (
+ request = `{"jsonrpc":"2.0","id":1,"method":"rpc_modules"}` + "\n"
+ wantResp = `{"jsonrpc":"2.0","id":1,"result":{"nftest":"1.0","rpc":"1.0","test":"1.0"}}` + "\n"
+ deadline = time.Now().Add(10 * time.Second)
+ )
+ for i := 0; i < 20; i++ {
+ conn, err := net.Dial("tcp", listener.Addr().String())
+ if err != nil {
+ t.Fatal("can't dial:", err)
+ }
+
+ conn.SetDeadline(deadline)
+ // Write the request, then half-close the connection so the server stops reading.
+ conn.Write([]byte(request))
+ conn.(*net.TCPConn).CloseWrite()
+ // Now try to get the response.
+ buf := make([]byte, 2000)
+ n, err := conn.Read(buf)
+ conn.Close()
+
+ if err != nil {
+ t.Fatal("read error:", err)
+ }
+ if !bytes.Equal(buf[:n], []byte(wantResp)) {
+ t.Fatalf("wrong response: %s", buf[:n])
+ }
+ }
+}
diff --git a/relayer/chainproxy/rpcclient/service.go b/relayer/chainproxy/rpcclient/service.go
new file mode 100755
index 0000000000..d536f4c613
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/service.go
@@ -0,0 +1,261 @@
+// Copyright 2019 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "reflect"
+ "runtime"
+ "strings"
+ "sync"
+ "unicode"
+
+ "github.com/ethereum/go-ethereum/log"
+)
+
+var (
+ contextType = reflect.TypeOf((*context.Context)(nil)).Elem()
+ errorType = reflect.TypeOf((*error)(nil)).Elem()
+ subscriptionType = reflect.TypeOf(Subscription{})
+ stringType = reflect.TypeOf("")
+)
+
+type serviceRegistry struct {
+ mu sync.Mutex
+ services map[string]service
+}
+
+// service represents a registered object.
+type service struct {
+ name string // name for service
+ callbacks map[string]*callback // registered handlers
+ subscriptions map[string]*callback // available subscriptions/notifications
+}
+
+// callback is a method callback which was registered in the server
+type callback struct {
+ fn reflect.Value // the function
+ rcvr reflect.Value // receiver object of method, set if fn is method
+ argTypes []reflect.Type // input argument types
+ hasCtx bool // method's first argument is a context (not included in argTypes)
+ errPos int // err return idx, of -1 when method cannot return error
+ isSubscribe bool // true if this is a subscription callback
+}
+
+func (r *serviceRegistry) registerName(name string, rcvr interface{}) error {
+ rcvrVal := reflect.ValueOf(rcvr)
+ if name == "" {
+ return fmt.Errorf("no service name for type %s", rcvrVal.Type().String())
+ }
+ callbacks := suitableCallbacks(rcvrVal)
+ if len(callbacks) == 0 {
+ return fmt.Errorf("service %T doesn't have any suitable methods/subscriptions to expose", rcvr)
+ }
+
+ r.mu.Lock()
+ defer r.mu.Unlock()
+ if r.services == nil {
+ r.services = make(map[string]service)
+ }
+ svc, ok := r.services[name]
+ if !ok {
+ svc = service{
+ name: name,
+ callbacks: make(map[string]*callback),
+ subscriptions: make(map[string]*callback),
+ }
+ r.services[name] = svc
+ }
+ for name, cb := range callbacks {
+ if cb.isSubscribe {
+ svc.subscriptions[name] = cb
+ } else {
+ svc.callbacks[name] = cb
+ }
+ }
+ return nil
+}
+
+// callback returns the callback corresponding to the given RPC method name.
+func (r *serviceRegistry) callback(method string) *callback {
+ elem := strings.SplitN(method, serviceMethodSeparator, 2)
+ if len(elem) != 2 {
+ return nil
+ }
+ r.mu.Lock()
+ defer r.mu.Unlock()
+ return r.services[elem[0]].callbacks[elem[1]]
+}
+
+// subscription returns a subscription callback in the given service.
+func (r *serviceRegistry) subscription(service, name string) *callback {
+ r.mu.Lock()
+ defer r.mu.Unlock()
+ return r.services[service].subscriptions[name]
+}
+
+// suitableCallbacks iterates over the methods of the given type. It determines if a method
+// satisfies the criteria for a RPC callback or a subscription callback and adds it to the
+// collection of callbacks. See server documentation for a summary of these criteria.
+func suitableCallbacks(receiver reflect.Value) map[string]*callback {
+ typ := receiver.Type()
+ callbacks := make(map[string]*callback)
+ for m := 0; m < typ.NumMethod(); m++ {
+ method := typ.Method(m)
+ if method.PkgPath != "" {
+ continue // method not exported
+ }
+ cb := newCallback(receiver, method.Func)
+ if cb == nil {
+ continue // function invalid
+ }
+ name := formatName(method.Name)
+ callbacks[name] = cb
+ }
+ return callbacks
+}
+
+// newCallback turns fn (a function) into a callback object. It returns nil if the function
+// is unsuitable as an RPC callback.
+func newCallback(receiver, fn reflect.Value) *callback {
+ fntype := fn.Type()
+ c := &callback{fn: fn, rcvr: receiver, errPos: -1, isSubscribe: isPubSub(fntype)}
+ // Determine parameter types. They must all be exported or builtin types.
+ c.makeArgTypes()
+
+ // Verify return types. The function must return at most one error
+ // and/or one other non-error value.
+ outs := make([]reflect.Type, fntype.NumOut())
+ for i := 0; i < fntype.NumOut(); i++ {
+ outs[i] = fntype.Out(i)
+ }
+ if len(outs) > 2 {
+ return nil
+ }
+ // If an error is returned, it must be the last returned value.
+ switch {
+ case len(outs) == 1 && isErrorType(outs[0]):
+ c.errPos = 0
+ case len(outs) == 2:
+ if isErrorType(outs[0]) || !isErrorType(outs[1]) {
+ return nil
+ }
+ c.errPos = 1
+ }
+ return c
+}
+
+// makeArgTypes composes the argTypes list.
+func (c *callback) makeArgTypes() {
+ fntype := c.fn.Type()
+ // Skip receiver and context.Context parameter (if present).
+ firstArg := 0
+ if c.rcvr.IsValid() {
+ firstArg++
+ }
+ if fntype.NumIn() > firstArg && fntype.In(firstArg) == contextType {
+ c.hasCtx = true
+ firstArg++
+ }
+ // Add all remaining parameters.
+ c.argTypes = make([]reflect.Type, fntype.NumIn()-firstArg)
+ for i := firstArg; i < fntype.NumIn(); i++ {
+ c.argTypes[i-firstArg] = fntype.In(i)
+ }
+}
+
+// call invokes the callback.
+func (c *callback) call(ctx context.Context, method string, args []reflect.Value) (res interface{}, errRes error) {
+ // Create the argument slice.
+ fullargs := make([]reflect.Value, 0, 2+len(args))
+ if c.rcvr.IsValid() {
+ fullargs = append(fullargs, c.rcvr)
+ }
+ if c.hasCtx {
+ fullargs = append(fullargs, reflect.ValueOf(ctx))
+ }
+ fullargs = append(fullargs, args...)
+
+ // Catch panic while running the callback.
+ defer func() {
+ if err := recover(); err != nil {
+ const size = 64 << 10
+ buf := make([]byte, size)
+ buf = buf[:runtime.Stack(buf, false)]
+ log.Error("RPC method " + method + " crashed: " + fmt.Sprintf("%v\n%s", err, buf))
+ errRes = errors.New("method handler crashed")
+ }
+ }()
+ // Run the callback.
+ results := c.fn.Call(fullargs)
+ if len(results) == 0 {
+ return nil, nil
+ }
+ if c.errPos >= 0 && !results[c.errPos].IsNil() {
+ // Method has returned non-nil error value.
+ err := results[c.errPos].Interface().(error)
+ return reflect.Value{}, err
+ }
+ return results[0].Interface(), nil
+}
+
+// Is t context.Context or *context.Context?
+func isContextType(t reflect.Type) bool {
+ for t.Kind() == reflect.Ptr {
+ t = t.Elem()
+ }
+ return t == contextType
+}
+
+// Does t satisfy the error interface?
+func isErrorType(t reflect.Type) bool {
+ for t.Kind() == reflect.Ptr {
+ t = t.Elem()
+ }
+ return t.Implements(errorType)
+}
+
+// Is t Subscription or *Subscription?
+func isSubscriptionType(t reflect.Type) bool {
+ for t.Kind() == reflect.Ptr {
+ t = t.Elem()
+ }
+ return t == subscriptionType
+}
+
+// isPubSub tests whether the given method has as as first argument a context.Context and
+// returns the pair (Subscription, error).
+func isPubSub(methodType reflect.Type) bool {
+ // numIn(0) is the receiver type
+ if methodType.NumIn() < 2 || methodType.NumOut() != 2 {
+ return false
+ }
+ return isContextType(methodType.In(1)) &&
+ isSubscriptionType(methodType.Out(0)) &&
+ isErrorType(methodType.Out(1))
+}
+
+// formatName converts to first character of name to lowercase.
+func formatName(name string) string {
+ ret := []rune(name)
+ if len(ret) > 0 {
+ ret[0] = unicode.ToLower(ret[0])
+ }
+ return string(ret)
+}
diff --git a/relayer/chainproxy/rpcclient/stdio.go b/relayer/chainproxy/rpcclient/stdio.go
new file mode 100755
index 0000000000..d6b0b5ee11
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/stdio.go
@@ -0,0 +1,66 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "context"
+ "errors"
+ "io"
+ "net"
+ "os"
+ "time"
+)
+
+// DialStdIO creates a client on stdin/stdout.
+func DialStdIO(ctx context.Context) (*Client, error) {
+ return DialIO(ctx, os.Stdin, os.Stdout)
+}
+
+// DialIO creates a client which uses the given IO channels
+func DialIO(ctx context.Context, in io.Reader, out io.Writer) (*Client, error) {
+ return newClient(ctx, func(_ context.Context) (ServerCodec, error) {
+ return NewCodec(stdioConn{
+ in: in,
+ out: out,
+ }), nil
+ })
+}
+
+type stdioConn struct {
+ in io.Reader
+ out io.Writer
+}
+
+func (io stdioConn) Read(b []byte) (n int, err error) {
+ return io.in.Read(b)
+}
+
+func (io stdioConn) Write(b []byte) (n int, err error) {
+ return io.out.Write(b)
+}
+
+func (io stdioConn) Close() error {
+ return nil
+}
+
+func (io stdioConn) RemoteAddr() string {
+ return "/dev/stdin"
+}
+
+func (io stdioConn) SetWriteDeadline(t time.Time) error {
+ return &net.OpError{Op: "set", Net: "stdio", Source: nil, Addr: nil, Err: errors.New("deadline not supported")}
+}
diff --git a/relayer/chainproxy/rpcclient/subscription.go b/relayer/chainproxy/rpcclient/subscription.go
new file mode 100755
index 0000000000..d0d9a4b80a
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/subscription.go
@@ -0,0 +1,375 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "container/list"
+ "context"
+ crand "crypto/rand"
+ "encoding/binary"
+ "encoding/hex"
+ "encoding/json"
+ "errors"
+ "math/rand"
+ "reflect"
+ "strings"
+ "sync"
+ "time"
+)
+
+var (
+ // ErrNotificationsUnsupported is returned when the connection doesn't support notifications
+ ErrNotificationsUnsupported = errors.New("notifications not supported")
+ // ErrSubscriptionNotFound is returned when the notification for the given id is not found
+ ErrSubscriptionNotFound = errors.New("subscription not found")
+)
+
+var globalGen = randomIDGenerator()
+
+// ID defines a pseudo random number that is used to identify RPC subscriptions.
+type ID string
+
+// NewID returns a new, random ID.
+func NewID() ID {
+ return globalGen()
+}
+
+// randomIDGenerator returns a function generates a random IDs.
+func randomIDGenerator() func() ID {
+ var buf = make([]byte, 8)
+ var seed int64
+ if _, err := crand.Read(buf); err == nil {
+ seed = int64(binary.BigEndian.Uint64(buf))
+ } else {
+ seed = int64(time.Now().Nanosecond())
+ }
+
+ var (
+ mu sync.Mutex
+ rng = rand.New(rand.NewSource(seed))
+ )
+ return func() ID {
+ mu.Lock()
+ defer mu.Unlock()
+ id := make([]byte, 16)
+ rng.Read(id)
+ return encodeID(id)
+ }
+}
+
+func encodeID(b []byte) ID {
+ id := hex.EncodeToString(b)
+ id = strings.TrimLeft(id, "0")
+ if id == "" {
+ id = "0" // ID's are RPC quantities, no leading zero's and 0 is 0x0.
+ }
+ return ID("0x" + id)
+}
+
+type notifierKey struct{}
+
+// NotifierFromContext returns the Notifier value stored in ctx, if any.
+func NotifierFromContext(ctx context.Context) (*Notifier, bool) {
+ n, ok := ctx.Value(notifierKey{}).(*Notifier)
+ return n, ok
+}
+
+// Notifier is tied to a RPC connection that supports subscriptions.
+// Server callbacks use the notifier to send notifications.
+type Notifier struct {
+ h *handler
+ namespace string
+
+ mu sync.Mutex
+ sub *Subscription
+ buffer []json.RawMessage
+ callReturned bool
+ activated bool
+}
+
+// CreateSubscription returns a new subscription that is coupled to the
+// RPC connection. By default subscriptions are inactive and notifications
+// are dropped until the subscription is marked as active. This is done
+// by the RPC server after the subscription ID is send to the client.
+func (n *Notifier) CreateSubscription() *Subscription {
+ n.mu.Lock()
+ defer n.mu.Unlock()
+
+ if n.sub != nil {
+ panic("can't create multiple subscriptions with Notifier")
+ } else if n.callReturned {
+ panic("can't create subscription after subscribe call has returned")
+ }
+ n.sub = &Subscription{ID: n.h.idgen(), namespace: n.namespace, err: make(chan error, 1)}
+ return n.sub
+}
+
+// Notify sends a notification to the client with the given data as payload.
+// If an error occurs the RPC connection is closed and the error is returned.
+func (n *Notifier) Notify(id ID, data interface{}) error {
+ enc, err := json.Marshal(data)
+ if err != nil {
+ return err
+ }
+
+ n.mu.Lock()
+ defer n.mu.Unlock()
+
+ if n.sub == nil {
+ panic("can't Notify before subscription is created")
+ } else if n.sub.ID != id {
+ panic("Notify with wrong ID")
+ }
+ if n.activated {
+ return n.send(n.sub, enc)
+ }
+ n.buffer = append(n.buffer, enc)
+ return nil
+}
+
+// Closed returns a channel that is closed when the RPC connection is closed.
+// Deprecated: use subscription error channel
+func (n *Notifier) Closed() <-chan interface{} {
+ return n.h.conn.closed()
+}
+
+// takeSubscription returns the subscription (if one has been created). No subscription can
+// be created after this call.
+func (n *Notifier) takeSubscription() *Subscription {
+ n.mu.Lock()
+ defer n.mu.Unlock()
+ n.callReturned = true
+ return n.sub
+}
+
+// activate is called after the subscription ID was sent to client. Notifications are
+// buffered before activation. This prevents notifications being sent to the client before
+// the subscription ID is sent to the client.
+func (n *Notifier) activate() error {
+ n.mu.Lock()
+ defer n.mu.Unlock()
+
+ for _, data := range n.buffer {
+ if err := n.send(n.sub, data); err != nil {
+ return err
+ }
+ }
+ n.activated = true
+ return nil
+}
+
+func (n *Notifier) send(sub *Subscription, data json.RawMessage) error {
+ params, _ := json.Marshal(&subscriptionResult{ID: string(sub.ID), Result: data})
+ ctx := context.Background()
+ return n.h.conn.writeJSON(ctx, &jsonrpcMessage{
+ Version: vsn,
+ Method: n.namespace + notificationMethodSuffix,
+ Params: params,
+ })
+}
+
+// A Subscription is created by a notifier and tied to that notifier. The client can use
+// this subscription to wait for an unsubscribe request for the client, see Err().
+type Subscription struct {
+ ID ID
+ namespace string
+ err chan error // closed on unsubscribe
+}
+
+// Err returns a channel that is closed when the client send an unsubscribe request.
+func (s *Subscription) Err() <-chan error {
+ return s.err
+}
+
+// MarshalJSON marshals a subscription as its ID.
+func (s *Subscription) MarshalJSON() ([]byte, error) {
+ return json.Marshal(s.ID)
+}
+
+// ClientSubscription is a subscription established through the Client's Subscribe or
+// EthSubscribe methods.
+type ClientSubscription struct {
+ client *Client
+ etype reflect.Type
+ channel reflect.Value
+ namespace string
+ subid string
+
+ // The in channel receives notification values from client dispatcher.
+ in chan json.RawMessage
+
+ // The error channel receives the error from the forwarding loop.
+ // It is closed by Unsubscribe.
+ err chan error
+ errOnce sync.Once
+
+ // Closing of the subscription is requested by sending on 'quit'. This is handled by
+ // the forwarding loop, which closes 'forwardDone' when it has stopped sending to
+ // sub.channel. Finally, 'unsubDone' is closed after unsubscribing on the server side.
+ quit chan error
+ forwardDone chan struct{}
+ unsubDone chan struct{}
+}
+
+// This is the sentinel value sent on sub.quit when Unsubscribe is called.
+var errUnsubscribed = errors.New("unsubscribed")
+
+func newClientSubscription(c *Client, namespace string, channel reflect.Value) *ClientSubscription {
+ sub := &ClientSubscription{
+ client: c,
+ namespace: namespace,
+ etype: channel.Type().Elem(),
+ channel: channel,
+ in: make(chan json.RawMessage),
+ quit: make(chan error),
+ forwardDone: make(chan struct{}),
+ unsubDone: make(chan struct{}),
+ err: make(chan error, 1),
+ }
+ return sub
+}
+
+// Err returns the subscription error channel. The intended use of Err is to schedule
+// resubscription when the client connection is closed unexpectedly.
+//
+// The error channel receives a value when the subscription has ended due to an error. The
+// received error is nil if Close has been called on the underlying client and no other
+// error has occurred.
+//
+// The error channel is closed when Unsubscribe is called on the subscription.
+func (sub *ClientSubscription) Err() <-chan error {
+ return sub.err
+}
+
+// Unsubscribe unsubscribes the notification and closes the error channel.
+// It can safely be called more than once.
+func (sub *ClientSubscription) Unsubscribe() {
+ sub.errOnce.Do(func() {
+ select {
+ case sub.quit <- errUnsubscribed:
+ <-sub.unsubDone
+ case <-sub.unsubDone:
+ }
+ close(sub.err)
+ })
+}
+
+// deliver is called by the client's message dispatcher to send a notification value.
+func (sub *ClientSubscription) deliver(result json.RawMessage) (ok bool) {
+ select {
+ case sub.in <- result:
+ return true
+ case <-sub.forwardDone:
+ return false
+ }
+}
+
+// close is called by the client's message dispatcher when the connection is closed.
+func (sub *ClientSubscription) close(err error) {
+ select {
+ case sub.quit <- err:
+ case <-sub.forwardDone:
+ }
+}
+
+// run is the forwarding loop of the subscription. It runs in its own goroutine and
+// is launched by the client's handler after the subscription has been created.
+func (sub *ClientSubscription) run() {
+ defer close(sub.unsubDone)
+
+ unsubscribe, err := sub.forward()
+
+ // The client's dispatch loop won't be able to execute the unsubscribe call if it is
+ // blocked in sub.deliver() or sub.close(). Closing forwardDone unblocks them.
+ close(sub.forwardDone)
+
+ // Call the unsubscribe method on the server.
+ if unsubscribe {
+ sub.requestUnsubscribe()
+ }
+
+ // Send the error.
+ if err != nil {
+ if err == ErrClientQuit {
+ // ErrClientQuit gets here when Client.Close is called. This is reported as a
+ // nil error because it's not an error, but we can't close sub.err here.
+ err = nil
+ }
+ sub.err <- err
+ }
+}
+
+// forward is the forwarding loop. It takes in RPC notifications and sends them
+// on the subscription channel.
+func (sub *ClientSubscription) forward() (unsubscribeServer bool, err error) {
+ cases := []reflect.SelectCase{
+ {Dir: reflect.SelectRecv, Chan: reflect.ValueOf(sub.quit)},
+ {Dir: reflect.SelectRecv, Chan: reflect.ValueOf(sub.in)},
+ {Dir: reflect.SelectSend, Chan: sub.channel},
+ }
+ buffer := list.New()
+
+ for {
+ var chosen int
+ var recv reflect.Value
+ if buffer.Len() == 0 {
+ // Idle, omit send case.
+ chosen, recv, _ = reflect.Select(cases[:2])
+ } else {
+ // Non-empty buffer, send the first queued item.
+ cases[2].Send = reflect.ValueOf(buffer.Front().Value)
+ chosen, recv, _ = reflect.Select(cases)
+ }
+
+ switch chosen {
+ case 0: // <-sub.quit
+ if !recv.IsNil() {
+ err = recv.Interface().(error)
+ }
+ if err == errUnsubscribed {
+ // Exiting because Unsubscribe was called, unsubscribe on server.
+ return true, nil
+ }
+ return false, err
+
+ case 1: // <-sub.in
+ val, err := sub.unmarshal(recv.Interface().(json.RawMessage))
+ if err != nil {
+ return true, err
+ }
+ if buffer.Len() == maxClientSubscriptionBuffer {
+ return true, ErrSubscriptionQueueOverflow
+ }
+ buffer.PushBack(val)
+
+ case 2: // sub.channel<-
+ cases[2].Send = reflect.Value{} // Don't hold onto the value.
+ buffer.Remove(buffer.Front())
+ }
+ }
+}
+
+func (sub *ClientSubscription) unmarshal(result json.RawMessage) (interface{}, error) {
+ val := reflect.New(sub.etype)
+ err := json.Unmarshal(result, val.Interface())
+ return val.Elem().Interface(), err
+}
+
+func (sub *ClientSubscription) requestUnsubscribe() error {
+ var result interface{}
+ return sub.client.Call(&result, sub.namespace+unsubscribeMethodSuffix, sub.subid)
+}
diff --git a/relayer/chainproxy/rpcclient/subscription_test.go b/relayer/chainproxy/rpcclient/subscription_test.go
new file mode 100755
index 0000000000..99df291e88
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/subscription_test.go
@@ -0,0 +1,220 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "encoding/json"
+ "fmt"
+ "net"
+ "strings"
+ "testing"
+ "time"
+)
+
+func TestNewID(t *testing.T) {
+ hexchars := "0123456789ABCDEFabcdef"
+ for i := 0; i < 100; i++ {
+ id := string(NewID())
+ if !strings.HasPrefix(id, "0x") {
+ t.Fatalf("invalid ID prefix, want '0x...', got %s", id)
+ }
+
+ id = id[2:]
+ if len(id) == 0 || len(id) > 32 {
+ t.Fatalf("invalid ID length, want len(id) > 0 && len(id) <= 32), got %d", len(id))
+ }
+
+ for i := 0; i < len(id); i++ {
+ if strings.IndexByte(hexchars, id[i]) == -1 {
+ t.Fatalf("unexpected byte, want any valid hex char, got %c", id[i])
+ }
+ }
+ }
+}
+
+func TestSubscriptions(t *testing.T) {
+ var (
+ namespaces = []string{"eth", "shh", "bzz"}
+ service = ¬ificationTestService{}
+ subCount = len(namespaces)
+ notificationCount = 3
+
+ server = NewServer()
+ clientConn, serverConn = net.Pipe()
+ out = json.NewEncoder(clientConn)
+ in = json.NewDecoder(clientConn)
+ successes = make(chan subConfirmation)
+ notifications = make(chan subscriptionResult)
+ errors = make(chan error, subCount*notificationCount+1)
+ )
+
+ // setup and start server
+ for _, namespace := range namespaces {
+ if err := server.RegisterName(namespace, service); err != nil {
+ t.Fatalf("unable to register test service %v", err)
+ }
+ }
+ go server.ServeCodec(NewCodec(serverConn), 0)
+ defer server.Stop()
+
+ // wait for message and write them to the given channels
+ go waitForMessages(in, successes, notifications, errors)
+
+ // create subscriptions one by one
+ for i, namespace := range namespaces {
+ request := map[string]interface{}{
+ "id": i,
+ "method": fmt.Sprintf("%s_subscribe", namespace),
+ "version": "2.0",
+ "params": []interface{}{"someSubscription", notificationCount, i},
+ }
+ if err := out.Encode(&request); err != nil {
+ t.Fatalf("Could not create subscription: %v", err)
+ }
+ }
+
+ timeout := time.After(30 * time.Second)
+ subids := make(map[string]string, subCount)
+ count := make(map[string]int, subCount)
+ allReceived := func() bool {
+ done := len(count) == subCount
+ for _, c := range count {
+ if c < notificationCount {
+ done = false
+ }
+ }
+ return done
+ }
+ for !allReceived() {
+ select {
+ case confirmation := <-successes: // subscription created
+ subids[namespaces[confirmation.reqid]] = string(confirmation.subid)
+ case notification := <-notifications:
+ count[notification.ID]++
+ case err := <-errors:
+ t.Fatal(err)
+ case <-timeout:
+ for _, namespace := range namespaces {
+ subid, found := subids[namespace]
+ if !found {
+ t.Errorf("subscription for %q not created", namespace)
+ continue
+ }
+ if count, found := count[subid]; !found || count < notificationCount {
+ t.Errorf("didn't receive all notifications (%d<%d) in time for namespace %q", count, notificationCount, namespace)
+ }
+ }
+ t.Fatal("timed out")
+ }
+ }
+}
+
+// This test checks that unsubscribing works.
+func TestServerUnsubscribe(t *testing.T) {
+ p1, p2 := net.Pipe()
+ defer p2.Close()
+
+ // Start the server.
+ server := newTestServer()
+ service := ¬ificationTestService{unsubscribed: make(chan string, 1)}
+ server.RegisterName("nftest2", service)
+ go server.ServeCodec(NewCodec(p1), 0)
+
+ // Subscribe.
+ p2.SetDeadline(time.Now().Add(10 * time.Second))
+ p2.Write([]byte(`{"jsonrpc":"2.0","id":1,"method":"nftest2_subscribe","params":["someSubscription",0,10]}`))
+
+ // Handle received messages.
+ var (
+ resps = make(chan subConfirmation)
+ notifications = make(chan subscriptionResult)
+ errors = make(chan error, 1)
+ )
+ go waitForMessages(json.NewDecoder(p2), resps, notifications, errors)
+
+ // Receive the subscription ID.
+ var sub subConfirmation
+ select {
+ case sub = <-resps:
+ case err := <-errors:
+ t.Fatal(err)
+ }
+
+ // Unsubscribe and check that it is handled on the server side.
+ p2.Write([]byte(`{"jsonrpc":"2.0","method":"nftest2_unsubscribe","params":["` + sub.subid + `"]}`))
+ for {
+ select {
+ case id := <-service.unsubscribed:
+ if id != string(sub.subid) {
+ t.Errorf("wrong subscription ID unsubscribed")
+ }
+ return
+ case err := <-errors:
+ t.Fatal(err)
+ case <-notifications:
+ // drop notifications
+ }
+ }
+}
+
+type subConfirmation struct {
+ reqid int
+ subid ID
+}
+
+// waitForMessages reads RPC messages from 'in' and dispatches them into the given channels.
+// It stops if there is an error.
+func waitForMessages(in *json.Decoder, successes chan subConfirmation, notifications chan subscriptionResult, errors chan error) {
+ for {
+ resp, notification, err := readAndValidateMessage(in)
+ if err != nil {
+ errors <- err
+ return
+ } else if resp != nil {
+ successes <- *resp
+ } else {
+ notifications <- *notification
+ }
+ }
+}
+
+func readAndValidateMessage(in *json.Decoder) (*subConfirmation, *subscriptionResult, error) {
+ var msg jsonrpcMessage
+ if err := in.Decode(&msg); err != nil {
+ return nil, nil, fmt.Errorf("decode error: %v", err)
+ }
+ switch {
+ case msg.isNotification():
+ var res subscriptionResult
+ if err := json.Unmarshal(msg.Params, &res); err != nil {
+ return nil, nil, fmt.Errorf("invalid subscription result: %v", err)
+ }
+ return nil, &res, nil
+ case msg.isResponse():
+ var c subConfirmation
+ if msg.Error != nil {
+ return nil, nil, msg.Error
+ } else if err := json.Unmarshal(msg.Result, &c.subid); err != nil {
+ return nil, nil, fmt.Errorf("invalid response: %v", err)
+ } else {
+ json.Unmarshal(msg.ID, &c.reqid)
+ return &c, nil, nil
+ }
+ default:
+ return nil, nil, fmt.Errorf("unrecognized message: %v", msg)
+ }
+}
diff --git a/relayer/chainproxy/rpcclient/testdata/invalid-badid.js b/relayer/chainproxy/rpcclient/testdata/invalid-badid.js
new file mode 100644
index 0000000000..2202b8ccd2
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/testdata/invalid-badid.js
@@ -0,0 +1,7 @@
+// This test checks processing of messages with invalid ID.
+
+--> {"id":[],"method":"test_foo"}
+<-- {"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"invalid request"}}
+
+--> {"id":{},"method":"test_foo"}
+<-- {"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"invalid request"}}
diff --git a/relayer/chainproxy/rpcclient/testdata/invalid-batch.js b/relayer/chainproxy/rpcclient/testdata/invalid-batch.js
new file mode 100644
index 0000000000..768dbc837e
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/testdata/invalid-batch.js
@@ -0,0 +1,17 @@
+// This test checks the behavior of batches with invalid elements.
+// Empty batches are not allowed. Batches may contain junk.
+
+--> []
+<-- {"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"empty batch"}}
+
+--> [1]
+<-- [{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"invalid request"}}]
+
+--> [1,2,3]
+<-- [{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"invalid request"}},{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"invalid request"}},{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"invalid request"}}]
+
+--> [null]
+<-- [{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"invalid request"}}]
+
+--> [{"jsonrpc":"2.0","id":1,"method":"test_echo","params":["foo",1]},55,{"jsonrpc":"2.0","id":2,"method":"unknown_method"},{"foo":"bar"}]
+<-- [{"jsonrpc":"2.0","id":1,"result":{"String":"foo","Int":1,"Args":null}},{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"invalid request"}},{"jsonrpc":"2.0","id":2,"error":{"code":-32601,"message":"the method unknown_method does not exist/is not available"}},{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"invalid request"}}]
diff --git a/relayer/chainproxy/rpcclient/testdata/invalid-idonly.js b/relayer/chainproxy/rpcclient/testdata/invalid-idonly.js
new file mode 100644
index 0000000000..79997bee30
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/testdata/invalid-idonly.js
@@ -0,0 +1,7 @@
+// This test checks processing of messages that contain just the ID and nothing else.
+
+--> {"id":1}
+<-- {"jsonrpc":"2.0","id":1,"error":{"code":-32600,"message":"invalid request"}}
+
+--> {"jsonrpc":"2.0","id":1}
+<-- {"jsonrpc":"2.0","id":1,"error":{"code":-32600,"message":"invalid request"}}
diff --git a/relayer/chainproxy/rpcclient/testdata/invalid-nonobj.js b/relayer/chainproxy/rpcclient/testdata/invalid-nonobj.js
new file mode 100644
index 0000000000..ffdd4a5b87
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/testdata/invalid-nonobj.js
@@ -0,0 +1,7 @@
+// This test checks behavior for invalid requests.
+
+--> 1
+<-- {"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"invalid request"}}
+
+--> null
+<-- {"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"invalid request"}}
diff --git a/relayer/chainproxy/rpcclient/testdata/invalid-syntax.json b/relayer/chainproxy/rpcclient/testdata/invalid-syntax.json
new file mode 100644
index 0000000000..b194299603
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/testdata/invalid-syntax.json
@@ -0,0 +1,5 @@
+// This test checks that an error is written for invalid JSON requests.
+
+--> 'f
+<-- {"jsonrpc":"2.0","id":null,"error":{"code":-32700,"message":"invalid character '\\'' looking for beginning of value"}}
+
diff --git a/relayer/chainproxy/rpcclient/testdata/reqresp-batch.js b/relayer/chainproxy/rpcclient/testdata/reqresp-batch.js
new file mode 100644
index 0000000000..977af76630
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/testdata/reqresp-batch.js
@@ -0,0 +1,8 @@
+// There is no response for all-notification batches.
+
+--> [{"jsonrpc":"2.0","method":"test_echo","params":["x",99]}]
+
+// This test checks regular batch calls.
+
+--> [{"jsonrpc":"2.0","id":2,"method":"test_echo","params":[]}, {"jsonrpc":"2.0","id": 3,"method":"test_echo","params":["x",3]}]
+<-- [{"jsonrpc":"2.0","id":2,"error":{"code":-32602,"message":"missing value for required argument 0"}},{"jsonrpc":"2.0","id":3,"result":{"String":"x","Int":3,"Args":null}}]
diff --git a/relayer/chainproxy/rpcclient/testdata/reqresp-echo.js b/relayer/chainproxy/rpcclient/testdata/reqresp-echo.js
new file mode 100644
index 0000000000..7a9e90321c
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/testdata/reqresp-echo.js
@@ -0,0 +1,16 @@
+// This test calls the test_echo method.
+
+--> {"jsonrpc": "2.0", "id": 2, "method": "test_echo", "params": []}
+<-- {"jsonrpc":"2.0","id":2,"error":{"code":-32602,"message":"missing value for required argument 0"}}
+
+--> {"jsonrpc": "2.0", "id": 2, "method": "test_echo", "params": ["x"]}
+<-- {"jsonrpc":"2.0","id":2,"error":{"code":-32602,"message":"missing value for required argument 1"}}
+
+--> {"jsonrpc": "2.0", "id": 2, "method": "test_echo", "params": ["x", 3]}
+<-- {"jsonrpc":"2.0","id":2,"result":{"String":"x","Int":3,"Args":null}}
+
+--> {"jsonrpc": "2.0", "id": 2, "method": "test_echo", "params": ["x", 3, {"S": "foo"}]}
+<-- {"jsonrpc":"2.0","id":2,"result":{"String":"x","Int":3,"Args":{"S":"foo"}}}
+
+--> {"jsonrpc": "2.0", "id": 2, "method": "test_echoWithCtx", "params": ["x", 3, {"S": "foo"}]}
+<-- {"jsonrpc":"2.0","id":2,"result":{"String":"x","Int":3,"Args":{"S":"foo"}}}
diff --git a/relayer/chainproxy/rpcclient/testdata/reqresp-namedparam.js b/relayer/chainproxy/rpcclient/testdata/reqresp-namedparam.js
new file mode 100644
index 0000000000..9a9372b0a7
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/testdata/reqresp-namedparam.js
@@ -0,0 +1,5 @@
+// This test checks that an error response is sent for calls
+// with named parameters.
+
+--> {"jsonrpc":"2.0","method":"test_echo","params":{"int":23},"id":3}
+<-- {"jsonrpc":"2.0","id":3,"error":{"code":-32602,"message":"non-array args"}}
diff --git a/relayer/chainproxy/rpcclient/testdata/reqresp-noargsrets.js b/relayer/chainproxy/rpcclient/testdata/reqresp-noargsrets.js
new file mode 100644
index 0000000000..e61cc708ba
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/testdata/reqresp-noargsrets.js
@@ -0,0 +1,4 @@
+// This test calls the test_noArgsRets method.
+
+--> {"jsonrpc": "2.0", "id": "foo", "method": "test_noArgsRets", "params": []}
+<-- {"jsonrpc":"2.0","id":"foo","result":null}
diff --git a/relayer/chainproxy/rpcclient/testdata/reqresp-nomethod.js b/relayer/chainproxy/rpcclient/testdata/reqresp-nomethod.js
new file mode 100644
index 0000000000..58ea6f3079
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/testdata/reqresp-nomethod.js
@@ -0,0 +1,4 @@
+// This test calls a method that doesn't exist.
+
+--> {"jsonrpc": "2.0", "id": 2, "method": "invalid_method", "params": [2, 3]}
+<-- {"jsonrpc":"2.0","id":2,"error":{"code":-32601,"message":"the method invalid_method does not exist/is not available"}}
diff --git a/relayer/chainproxy/rpcclient/testdata/reqresp-noparam.js b/relayer/chainproxy/rpcclient/testdata/reqresp-noparam.js
new file mode 100644
index 0000000000..2edf486d9f
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/testdata/reqresp-noparam.js
@@ -0,0 +1,4 @@
+// This test checks that calls with no parameters work.
+
+--> {"jsonrpc":"2.0","method":"test_noArgsRets","id":3}
+<-- {"jsonrpc":"2.0","id":3,"result":null}
diff --git a/relayer/chainproxy/rpcclient/testdata/reqresp-paramsnull.js b/relayer/chainproxy/rpcclient/testdata/reqresp-paramsnull.js
new file mode 100644
index 0000000000..8a01bae1bb
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/testdata/reqresp-paramsnull.js
@@ -0,0 +1,4 @@
+// This test checks that calls with "params":null work.
+
+--> {"jsonrpc":"2.0","method":"test_noArgsRets","params":null,"id":3}
+<-- {"jsonrpc":"2.0","id":3,"result":null}
diff --git a/relayer/chainproxy/rpcclient/testdata/revcall.js b/relayer/chainproxy/rpcclient/testdata/revcall.js
new file mode 100644
index 0000000000..695d9858f8
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/testdata/revcall.js
@@ -0,0 +1,6 @@
+// This test checks reverse calls.
+
+--> {"jsonrpc":"2.0","id":2,"method":"test_callMeBack","params":["foo",[1]]}
+<-- {"jsonrpc":"2.0","id":1,"method":"foo","params":[1]}
+--> {"jsonrpc":"2.0","id":1,"result":"my result"}
+<-- {"jsonrpc":"2.0","id":2,"result":"my result"}
diff --git a/relayer/chainproxy/rpcclient/testdata/revcall2.js b/relayer/chainproxy/rpcclient/testdata/revcall2.js
new file mode 100644
index 0000000000..acab46551e
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/testdata/revcall2.js
@@ -0,0 +1,7 @@
+// This test checks reverse calls.
+
+--> {"jsonrpc":"2.0","id":2,"method":"test_callMeBackLater","params":["foo",[1]]}
+<-- {"jsonrpc":"2.0","id":2,"result":null}
+<-- {"jsonrpc":"2.0","id":1,"method":"foo","params":[1]}
+--> {"jsonrpc":"2.0","id":1,"result":"my result"}
+
diff --git a/relayer/chainproxy/rpcclient/testdata/subscription.js b/relayer/chainproxy/rpcclient/testdata/subscription.js
new file mode 100644
index 0000000000..9f10073010
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/testdata/subscription.js
@@ -0,0 +1,12 @@
+// This test checks basic subscription support.
+
+--> {"jsonrpc":"2.0","id":1,"method":"nftest_subscribe","params":["someSubscription",5,1]}
+<-- {"jsonrpc":"2.0","id":1,"result":"0x1"}
+<-- {"jsonrpc":"2.0","method":"nftest_subscription","params":{"subscription":"0x1","result":1}}
+<-- {"jsonrpc":"2.0","method":"nftest_subscription","params":{"subscription":"0x1","result":2}}
+<-- {"jsonrpc":"2.0","method":"nftest_subscription","params":{"subscription":"0x1","result":3}}
+<-- {"jsonrpc":"2.0","method":"nftest_subscription","params":{"subscription":"0x1","result":4}}
+<-- {"jsonrpc":"2.0","method":"nftest_subscription","params":{"subscription":"0x1","result":5}}
+
+--> {"jsonrpc":"2.0","id":2,"method":"nftest_echo","params":[11]}
+<-- {"jsonrpc":"2.0","id":2,"result":11}
diff --git a/relayer/chainproxy/rpcclient/testservice_test.go b/relayer/chainproxy/rpcclient/testservice_test.go
new file mode 100755
index 0000000000..f4384c820d
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/testservice_test.go
@@ -0,0 +1,210 @@
+// Copyright 2019 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "context"
+ "encoding/binary"
+ "errors"
+ "strings"
+ "sync"
+ "time"
+)
+
+func newTestServer() *Server {
+ server := NewServer()
+ server.idgen = sequentialIDGenerator()
+ if err := server.RegisterName("test", new(testService)); err != nil {
+ panic(err)
+ }
+ if err := server.RegisterName("nftest", new(notificationTestService)); err != nil {
+ panic(err)
+ }
+ return server
+}
+
+func sequentialIDGenerator() func() ID {
+ var (
+ mu sync.Mutex
+ counter uint64
+ )
+ return func() ID {
+ mu.Lock()
+ defer mu.Unlock()
+ counter++
+ id := make([]byte, 8)
+ binary.BigEndian.PutUint64(id, counter)
+ return encodeID(id)
+ }
+}
+
+type testService struct{}
+
+type echoArgs struct {
+ S string
+}
+
+type echoResult struct {
+ String string
+ Int int
+ Args *echoArgs
+}
+
+type testError struct{}
+
+func (testError) Error() string { return "testError" }
+func (testError) ErrorCode() int { return 444 }
+func (testError) ErrorData() interface{} { return "testError data" }
+
+func (s *testService) NoArgsRets() {}
+
+func (s *testService) Echo(str string, i int, args *echoArgs) echoResult {
+ return echoResult{str, i, args}
+}
+
+func (s *testService) EchoWithCtx(ctx context.Context, str string, i int, args *echoArgs) echoResult {
+ return echoResult{str, i, args}
+}
+
+func (s *testService) PeerInfo(ctx context.Context) PeerInfo {
+ return PeerInfoFromContext(ctx)
+}
+
+func (s *testService) Sleep(ctx context.Context, duration time.Duration) {
+ time.Sleep(duration)
+}
+
+func (s *testService) Block(ctx context.Context) error {
+ <-ctx.Done()
+ return errors.New("context canceled in testservice_block")
+}
+
+func (s *testService) Rets() (string, error) {
+ return "", nil
+}
+
+//lint:ignore ST1008 returns error first on purpose.
+func (s *testService) InvalidRets1() (error, string) {
+ return nil, ""
+}
+
+func (s *testService) InvalidRets2() (string, string) {
+ return "", ""
+}
+
+func (s *testService) InvalidRets3() (string, string, error) {
+ return "", "", nil
+}
+
+func (s *testService) ReturnError() error {
+ return testError{}
+}
+
+func (s *testService) CallMeBack(ctx context.Context, method string, args []interface{}) (interface{}, error) {
+ c, ok := ClientFromContext(ctx)
+ if !ok {
+ return nil, errors.New("no client")
+ }
+ var result interface{}
+ err := c.Call(&result, method, args...)
+ return result, err
+}
+
+func (s *testService) CallMeBackLater(ctx context.Context, method string, args []interface{}) error {
+ c, ok := ClientFromContext(ctx)
+ if !ok {
+ return errors.New("no client")
+ }
+ go func() {
+ <-ctx.Done()
+ var result interface{}
+ c.Call(&result, method, args...)
+ }()
+ return nil
+}
+
+func (s *testService) Subscription(ctx context.Context) (*Subscription, error) {
+ return nil, nil
+}
+
+type notificationTestService struct {
+ unsubscribed chan string
+ gotHangSubscriptionReq chan struct{}
+ unblockHangSubscription chan struct{}
+}
+
+func (s *notificationTestService) Echo(i int) int {
+ return i
+}
+
+func (s *notificationTestService) Unsubscribe(subid string) {
+ if s.unsubscribed != nil {
+ s.unsubscribed <- subid
+ }
+}
+
+func (s *notificationTestService) SomeSubscription(ctx context.Context, n, val int) (*Subscription, error) {
+ notifier, supported := NotifierFromContext(ctx)
+ if !supported {
+ return nil, ErrNotificationsUnsupported
+ }
+
+ // By explicitly creating an subscription we make sure that the subscription id is send
+ // back to the client before the first subscription.Notify is called. Otherwise the
+ // events might be send before the response for the *_subscribe method.
+ subscription := notifier.CreateSubscription()
+ go func() {
+ for i := 0; i < n; i++ {
+ if err := notifier.Notify(subscription.ID, val+i); err != nil {
+ return
+ }
+ }
+ select {
+ case <-notifier.Closed():
+ case <-subscription.Err():
+ }
+ if s.unsubscribed != nil {
+ s.unsubscribed <- string(subscription.ID)
+ }
+ }()
+ return subscription, nil
+}
+
+// HangSubscription blocks on s.unblockHangSubscription before sending anything.
+func (s *notificationTestService) HangSubscription(ctx context.Context, val int) (*Subscription, error) {
+ notifier, supported := NotifierFromContext(ctx)
+ if !supported {
+ return nil, ErrNotificationsUnsupported
+ }
+ s.gotHangSubscriptionReq <- struct{}{}
+ <-s.unblockHangSubscription
+ subscription := notifier.CreateSubscription()
+
+ go func() {
+ notifier.Notify(subscription.ID, val)
+ }()
+ return subscription, nil
+}
+
+// largeRespService generates arbitrary-size JSON responses.
+type largeRespService struct {
+ length int
+}
+
+func (x largeRespService) LargeResp() string {
+ return strings.Repeat("x", x.length)
+}
diff --git a/relayer/chainproxy/rpcclient/types.go b/relayer/chainproxy/rpcclient/types.go
new file mode 100755
index 0000000000..37b8df3fc5
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/types.go
@@ -0,0 +1,254 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "math"
+ "strconv"
+ "strings"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
+)
+
+// API describes the set of methods offered over the RPC interface
+type API struct {
+ Namespace string // namespace under which the rpc methods of Service are exposed
+ Version string // api version for DApp's
+ Service interface{} // receiver instance which holds the methods
+ Public bool // indication if the methods must be considered safe for public use
+ Authenticated bool // whether the api should only be available behind authentication.
+}
+
+// ServerCodec implements reading, parsing and writing RPC messages for the server side of
+// a RPC session. Implementations must be go-routine safe since the codec can be called in
+// multiple go-routines concurrently.
+type ServerCodec interface {
+ peerInfo() PeerInfo
+ readBatch() (msgs []*jsonrpcMessage, isBatch bool, err error)
+ close()
+
+ jsonWriter
+}
+
+// jsonWriter can write JSON messages to its underlying connection.
+// Implementations must be safe for concurrent use.
+type jsonWriter interface {
+ writeJSON(context.Context, interface{}) error
+ // Closed returns a channel which is closed when the connection is closed.
+ closed() <-chan interface{}
+ // RemoteAddr returns the peer address of the connection.
+ remoteAddr() string
+}
+
+type BlockNumber int64
+
+const (
+ FinalizedBlockNumber = BlockNumber(-3)
+ PendingBlockNumber = BlockNumber(-2)
+ LatestBlockNumber = BlockNumber(-1)
+ EarliestBlockNumber = BlockNumber(0)
+)
+
+// UnmarshalJSON parses the given JSON fragment into a BlockNumber. It supports:
+// - "latest", "earliest" or "pending" as string arguments
+// - the block number
+// Returned errors:
+// - an invalid block number error when the given argument isn't a known strings
+// - an out of range error when the given block number is either too little or too large
+func (bn *BlockNumber) UnmarshalJSON(data []byte) error {
+ input := strings.TrimSpace(string(data))
+ if len(input) >= 2 && input[0] == '"' && input[len(input)-1] == '"' {
+ input = input[1 : len(input)-1]
+ }
+
+ switch input {
+ case "earliest":
+ *bn = EarliestBlockNumber
+ return nil
+ case "latest":
+ *bn = LatestBlockNumber
+ return nil
+ case "pending":
+ *bn = PendingBlockNumber
+ return nil
+ case "finalized":
+ *bn = FinalizedBlockNumber
+ return nil
+ }
+
+ blckNum, err := hexutil.DecodeUint64(input)
+ if err != nil {
+ return err
+ }
+ if blckNum > math.MaxInt64 {
+ return fmt.Errorf("block number larger than int64")
+ }
+ *bn = BlockNumber(blckNum)
+ return nil
+}
+
+// MarshalText implements encoding.TextMarshaler. It marshals:
+// - "latest", "earliest" or "pending" as strings
+// - other numbers as hex
+func (bn BlockNumber) MarshalText() ([]byte, error) {
+ switch bn {
+ case EarliestBlockNumber:
+ return []byte("earliest"), nil
+ case LatestBlockNumber:
+ return []byte("latest"), nil
+ case PendingBlockNumber:
+ return []byte("pending"), nil
+ case FinalizedBlockNumber:
+ return []byte("finalized"), nil
+ default:
+ return hexutil.Uint64(bn).MarshalText()
+ }
+}
+
+func (bn BlockNumber) Int64() int64 {
+ return (int64)(bn)
+}
+
+type BlockNumberOrHash struct {
+ BlockNumber *BlockNumber `json:"blockNumber,omitempty"`
+ BlockHash *common.Hash `json:"blockHash,omitempty"`
+ RequireCanonical bool `json:"requireCanonical,omitempty"`
+}
+
+func (bnh *BlockNumberOrHash) UnmarshalJSON(data []byte) error {
+ type erased BlockNumberOrHash
+ e := erased{}
+ err := json.Unmarshal(data, &e)
+ if err == nil {
+ if e.BlockNumber != nil && e.BlockHash != nil {
+ return fmt.Errorf("cannot specify both BlockHash and BlockNumber, choose one or the other")
+ }
+ bnh.BlockNumber = e.BlockNumber
+ bnh.BlockHash = e.BlockHash
+ bnh.RequireCanonical = e.RequireCanonical
+ return nil
+ }
+ var input string
+ err = json.Unmarshal(data, &input)
+ if err != nil {
+ return err
+ }
+ switch input {
+ case "earliest":
+ bn := EarliestBlockNumber
+ bnh.BlockNumber = &bn
+ return nil
+ case "latest":
+ bn := LatestBlockNumber
+ bnh.BlockNumber = &bn
+ return nil
+ case "pending":
+ bn := PendingBlockNumber
+ bnh.BlockNumber = &bn
+ return nil
+ case "finalized":
+ bn := FinalizedBlockNumber
+ bnh.BlockNumber = &bn
+ return nil
+ default:
+ if len(input) == 66 {
+ hash := common.Hash{}
+ err := hash.UnmarshalText([]byte(input))
+ if err != nil {
+ return err
+ }
+ bnh.BlockHash = &hash
+ return nil
+ } else {
+ blckNum, err := hexutil.DecodeUint64(input)
+ if err != nil {
+ return err
+ }
+ if blckNum > math.MaxInt64 {
+ return fmt.Errorf("blocknumber too high")
+ }
+ bn := BlockNumber(blckNum)
+ bnh.BlockNumber = &bn
+ return nil
+ }
+ }
+}
+
+func (bnh *BlockNumberOrHash) Number() (BlockNumber, bool) {
+ if bnh.BlockNumber != nil {
+ return *bnh.BlockNumber, true
+ }
+ return BlockNumber(0), false
+}
+
+func (bnh *BlockNumberOrHash) String() string {
+ if bnh.BlockNumber != nil {
+ return strconv.Itoa(int(*bnh.BlockNumber))
+ }
+ if bnh.BlockHash != nil {
+ return bnh.BlockHash.String()
+ }
+ return "nil"
+}
+
+func (bnh *BlockNumberOrHash) Hash() (common.Hash, bool) {
+ if bnh.BlockHash != nil {
+ return *bnh.BlockHash, true
+ }
+ return common.Hash{}, false
+}
+
+func BlockNumberOrHashWithNumber(blockNr BlockNumber) BlockNumberOrHash {
+ return BlockNumberOrHash{
+ BlockNumber: &blockNr,
+ BlockHash: nil,
+ RequireCanonical: false,
+ }
+}
+
+func BlockNumberOrHashWithHash(hash common.Hash, canonical bool) BlockNumberOrHash {
+ return BlockNumberOrHash{
+ BlockNumber: nil,
+ BlockHash: &hash,
+ RequireCanonical: canonical,
+ }
+}
+
+// DecimalOrHex unmarshals a non-negative decimal or hex parameter into a uint64.
+type DecimalOrHex uint64
+
+// UnmarshalJSON implements json.Unmarshaler.
+func (dh *DecimalOrHex) UnmarshalJSON(data []byte) error {
+ input := strings.TrimSpace(string(data))
+ if len(input) >= 2 && input[0] == '"' && input[len(input)-1] == '"' {
+ input = input[1 : len(input)-1]
+ }
+
+ value, err := strconv.ParseUint(input, 10, 64)
+ if err != nil {
+ value, err = hexutil.DecodeUint64(input)
+ }
+ if err != nil {
+ return err
+ }
+ *dh = DecimalOrHex(value)
+ return nil
+}
diff --git a/relayer/chainproxy/rpcclient/types_test.go b/relayer/chainproxy/rpcclient/types_test.go
new file mode 100755
index 0000000000..2d34568d06
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/types_test.go
@@ -0,0 +1,155 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "encoding/json"
+ "reflect"
+ "testing"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/math"
+)
+
+func TestBlockNumberJSONUnmarshal(t *testing.T) {
+ tests := []struct {
+ input string
+ mustFail bool
+ expected BlockNumber
+ }{
+ 0: {`"0x"`, true, BlockNumber(0)},
+ 1: {`"0x0"`, false, BlockNumber(0)},
+ 2: {`"0X1"`, false, BlockNumber(1)},
+ 3: {`"0x00"`, true, BlockNumber(0)},
+ 4: {`"0x01"`, true, BlockNumber(0)},
+ 5: {`"0x1"`, false, BlockNumber(1)},
+ 6: {`"0x12"`, false, BlockNumber(18)},
+ 7: {`"0x7fffffffffffffff"`, false, BlockNumber(math.MaxInt64)},
+ 8: {`"0x8000000000000000"`, true, BlockNumber(0)},
+ 9: {"0", true, BlockNumber(0)},
+ 10: {`"ff"`, true, BlockNumber(0)},
+ 11: {`"pending"`, false, PendingBlockNumber},
+ 12: {`"latest"`, false, LatestBlockNumber},
+ 13: {`"earliest"`, false, EarliestBlockNumber},
+ 14: {`someString`, true, BlockNumber(0)},
+ 15: {`""`, true, BlockNumber(0)},
+ 16: {``, true, BlockNumber(0)},
+ }
+
+ for i, test := range tests {
+ var num BlockNumber
+ err := json.Unmarshal([]byte(test.input), &num)
+ if test.mustFail && err == nil {
+ t.Errorf("Test %d should fail", i)
+ continue
+ }
+ if !test.mustFail && err != nil {
+ t.Errorf("Test %d should pass but got err: %v", i, err)
+ continue
+ }
+ if num != test.expected {
+ t.Errorf("Test %d got unexpected value, want %d, got %d", i, test.expected, num)
+ }
+ }
+}
+
+func TestBlockNumberOrHash_UnmarshalJSON(t *testing.T) {
+ tests := []struct {
+ input string
+ mustFail bool
+ expected BlockNumberOrHash
+ }{
+ 0: {`"0x"`, true, BlockNumberOrHash{}},
+ 1: {`"0x0"`, false, BlockNumberOrHashWithNumber(0)},
+ 2: {`"0X1"`, false, BlockNumberOrHashWithNumber(1)},
+ 3: {`"0x00"`, true, BlockNumberOrHash{}},
+ 4: {`"0x01"`, true, BlockNumberOrHash{}},
+ 5: {`"0x1"`, false, BlockNumberOrHashWithNumber(1)},
+ 6: {`"0x12"`, false, BlockNumberOrHashWithNumber(18)},
+ 7: {`"0x7fffffffffffffff"`, false, BlockNumberOrHashWithNumber(math.MaxInt64)},
+ 8: {`"0x8000000000000000"`, true, BlockNumberOrHash{}},
+ 9: {"0", true, BlockNumberOrHash{}},
+ 10: {`"ff"`, true, BlockNumberOrHash{}},
+ 11: {`"pending"`, false, BlockNumberOrHashWithNumber(PendingBlockNumber)},
+ 12: {`"latest"`, false, BlockNumberOrHashWithNumber(LatestBlockNumber)},
+ 13: {`"earliest"`, false, BlockNumberOrHashWithNumber(EarliestBlockNumber)},
+ 14: {`someString`, true, BlockNumberOrHash{}},
+ 15: {`""`, true, BlockNumberOrHash{}},
+ 16: {``, true, BlockNumberOrHash{}},
+ 17: {`"0x0000000000000000000000000000000000000000000000000000000000000000"`, false, BlockNumberOrHashWithHash(common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"), false)},
+ 18: {`{"blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000"}`, false, BlockNumberOrHashWithHash(common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"), false)},
+ 19: {`{"blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","requireCanonical":false}`, false, BlockNumberOrHashWithHash(common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"), false)},
+ 20: {`{"blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","requireCanonical":true}`, false, BlockNumberOrHashWithHash(common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"), true)},
+ 21: {`{"blockNumber":"0x1"}`, false, BlockNumberOrHashWithNumber(1)},
+ 22: {`{"blockNumber":"pending"}`, false, BlockNumberOrHashWithNumber(PendingBlockNumber)},
+ 23: {`{"blockNumber":"latest"}`, false, BlockNumberOrHashWithNumber(LatestBlockNumber)},
+ 24: {`{"blockNumber":"earliest"}`, false, BlockNumberOrHashWithNumber(EarliestBlockNumber)},
+ 25: {`{"blockNumber":"0x1", "blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000"}`, true, BlockNumberOrHash{}},
+ }
+
+ for i, test := range tests {
+ var bnh BlockNumberOrHash
+ err := json.Unmarshal([]byte(test.input), &bnh)
+ if test.mustFail && err == nil {
+ t.Errorf("Test %d should fail", i)
+ continue
+ }
+ if !test.mustFail && err != nil {
+ t.Errorf("Test %d should pass but got err: %v", i, err)
+ continue
+ }
+ hash, hashOk := bnh.Hash()
+ expectedHash, expectedHashOk := test.expected.Hash()
+ num, numOk := bnh.Number()
+ expectedNum, expectedNumOk := test.expected.Number()
+ if bnh.RequireCanonical != test.expected.RequireCanonical ||
+ hash != expectedHash || hashOk != expectedHashOk ||
+ num != expectedNum || numOk != expectedNumOk {
+ t.Errorf("Test %d got unexpected value, want %v, got %v", i, test.expected, bnh)
+ }
+ }
+}
+
+func TestBlockNumberOrHash_WithNumber_MarshalAndUnmarshal(t *testing.T) {
+ tests := []struct {
+ name string
+ number int64
+ }{
+ {"max", math.MaxInt64},
+ {"pending", int64(PendingBlockNumber)},
+ {"latest", int64(LatestBlockNumber)},
+ {"earliest", int64(EarliestBlockNumber)},
+ }
+ for _, test := range tests {
+ test := test
+ t.Run(test.name, func(t *testing.T) {
+ bnh := BlockNumberOrHashWithNumber(BlockNumber(test.number))
+ marshalled, err := json.Marshal(bnh)
+ if err != nil {
+ t.Fatal("cannot marshal:", err)
+ }
+ var unmarshalled BlockNumberOrHash
+ err = json.Unmarshal(marshalled, &unmarshalled)
+ if err != nil {
+ t.Fatal("cannot unmarshal:", err)
+ }
+ if !reflect.DeepEqual(bnh, unmarshalled) {
+ t.Fatalf("wrong result: expected %v, got %v", bnh, unmarshalled)
+ }
+ })
+ }
+}
diff --git a/relayer/chainproxy/rpcclient/websocket.go b/relayer/chainproxy/rpcclient/websocket.go
new file mode 100755
index 0000000000..ebdcaa0fd8
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/websocket.go
@@ -0,0 +1,314 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "context"
+ "encoding/base64"
+ "fmt"
+ "net/http"
+ "net/url"
+ "os"
+ "strings"
+ "sync"
+ "time"
+
+ mapset "github.com/deckarep/golang-set"
+ "github.com/ethereum/go-ethereum/log"
+ "github.com/gorilla/websocket"
+)
+
+const (
+ wsReadBuffer = 1024
+ wsWriteBuffer = 1024
+ wsPingInterval = 60 * time.Second
+ wsPingWriteTimeout = 5 * time.Second
+ wsPongTimeout = 30 * time.Second
+ wsMessageSizeLimit = 15 * 1024 * 1024
+)
+
+var wsBufferPool = new(sync.Pool)
+
+// WebsocketHandler returns a handler that serves JSON-RPC to WebSocket connections.
+//
+// allowedOrigins should be a comma-separated list of allowed origin URLs.
+// To allow connections with any origin, pass "*".
+func (s *Server) WebsocketHandler(allowedOrigins []string) http.Handler {
+ var upgrader = websocket.Upgrader{
+ ReadBufferSize: wsReadBuffer,
+ WriteBufferSize: wsWriteBuffer,
+ WriteBufferPool: wsBufferPool,
+ CheckOrigin: wsHandshakeValidator(allowedOrigins),
+ }
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ conn, err := upgrader.Upgrade(w, r, nil)
+ if err != nil {
+ log.Debug("WebSocket upgrade failed", "err", err)
+ return
+ }
+ codec := newWebsocketCodec(conn, r.Host, r.Header)
+ s.ServeCodec(codec, 0)
+ })
+}
+
+// wsHandshakeValidator returns a handler that verifies the origin during the
+// websocket upgrade process. When a '*' is specified as an allowed origins all
+// connections are accepted.
+func wsHandshakeValidator(allowedOrigins []string) func(*http.Request) bool {
+ origins := mapset.NewSet()
+ allowAllOrigins := false
+
+ for _, origin := range allowedOrigins {
+ if origin == "*" {
+ allowAllOrigins = true
+ }
+ if origin != "" {
+ origins.Add(origin)
+ }
+ }
+ // allow localhost if no allowedOrigins are specified.
+ if len(origins.ToSlice()) == 0 {
+ origins.Add("http://localhost")
+ if hostname, err := os.Hostname(); err == nil {
+ origins.Add("http://" + hostname)
+ }
+ }
+ log.Debug(fmt.Sprintf("Allowed origin(s) for WS RPC interface %v", origins.ToSlice()))
+
+ f := func(req *http.Request) bool {
+ // Skip origin verification if no Origin header is present. The origin check
+ // is supposed to protect against browser based attacks. Browsers always set
+ // Origin. Non-browser software can put anything in origin and checking it doesn't
+ // provide additional security.
+ if _, ok := req.Header["Origin"]; !ok {
+ return true
+ }
+ // Verify origin against allow list.
+ origin := strings.ToLower(req.Header.Get("Origin"))
+ if allowAllOrigins || originIsAllowed(origins, origin) {
+ return true
+ }
+ log.Warn("Rejected WebSocket connection", "origin", origin)
+ return false
+ }
+
+ return f
+}
+
+type wsHandshakeError struct {
+ err error
+ status string
+}
+
+func (e wsHandshakeError) Error() string {
+ s := e.err.Error()
+ if e.status != "" {
+ s += " (HTTP status " + e.status + ")"
+ }
+ return s
+}
+
+func originIsAllowed(allowedOrigins mapset.Set, browserOrigin string) bool {
+ it := allowedOrigins.Iterator()
+ for origin := range it.C {
+ if ruleAllowsOrigin(origin.(string), browserOrigin) {
+ return true
+ }
+ }
+ return false
+}
+
+func ruleAllowsOrigin(allowedOrigin string, browserOrigin string) bool {
+ var (
+ allowedScheme, allowedHostname, allowedPort string
+ browserScheme, browserHostname, browserPort string
+ err error
+ )
+ allowedScheme, allowedHostname, allowedPort, err = parseOriginURL(allowedOrigin)
+ if err != nil {
+ log.Warn("Error parsing allowed origin specification", "spec", allowedOrigin, "error", err)
+ return false
+ }
+ browserScheme, browserHostname, browserPort, err = parseOriginURL(browserOrigin)
+ if err != nil {
+ log.Warn("Error parsing browser 'Origin' field", "Origin", browserOrigin, "error", err)
+ return false
+ }
+ if allowedScheme != "" && allowedScheme != browserScheme {
+ return false
+ }
+ if allowedHostname != "" && allowedHostname != browserHostname {
+ return false
+ }
+ if allowedPort != "" && allowedPort != browserPort {
+ return false
+ }
+ return true
+}
+
+func parseOriginURL(origin string) (string, string, string, error) {
+ parsedURL, err := url.Parse(strings.ToLower(origin))
+ if err != nil {
+ return "", "", "", err
+ }
+ var scheme, hostname, port string
+ if strings.Contains(origin, "://") {
+ scheme = parsedURL.Scheme
+ hostname = parsedURL.Hostname()
+ port = parsedURL.Port()
+ } else {
+ scheme = ""
+ hostname = parsedURL.Scheme
+ port = parsedURL.Opaque
+ if hostname == "" {
+ hostname = origin
+ }
+ }
+ return scheme, hostname, port, nil
+}
+
+// DialWebsocketWithDialer creates a new RPC client that communicates with a JSON-RPC server
+// that is listening on the given endpoint using the provided dialer.
+func DialWebsocketWithDialer(ctx context.Context, endpoint, origin string, dialer websocket.Dialer) (*Client, error) {
+ endpoint, header, err := wsClientHeaders(endpoint, origin)
+ if err != nil {
+ return nil, err
+ }
+ return newClient(ctx, func(ctx context.Context) (ServerCodec, error) {
+ conn, resp, err := dialer.DialContext(ctx, endpoint, header)
+ if err != nil {
+ hErr := wsHandshakeError{err: err}
+ if resp != nil {
+ hErr.status = resp.Status
+ }
+ return nil, hErr
+ }
+ return newWebsocketCodec(conn, endpoint, header), nil
+ })
+}
+
+// DialWebsocket creates a new RPC client that communicates with a JSON-RPC server
+// that is listening on the given endpoint.
+//
+// The context is used for the initial connection establishment. It does not
+// affect subsequent interactions with the client.
+func DialWebsocket(ctx context.Context, endpoint, origin string) (*Client, error) {
+ dialer := websocket.Dialer{
+ ReadBufferSize: wsReadBuffer,
+ WriteBufferSize: wsWriteBuffer,
+ WriteBufferPool: wsBufferPool,
+ }
+ return DialWebsocketWithDialer(ctx, endpoint, origin, dialer)
+}
+
+func wsClientHeaders(endpoint, origin string) (string, http.Header, error) {
+ endpointURL, err := url.Parse(endpoint)
+ if err != nil {
+ return endpoint, nil, err
+ }
+ header := make(http.Header)
+ if origin != "" {
+ header.Add("origin", origin)
+ }
+ if endpointURL.User != nil {
+ b64auth := base64.StdEncoding.EncodeToString([]byte(endpointURL.User.String()))
+ header.Add("authorization", "Basic "+b64auth)
+ endpointURL.User = nil
+ }
+ return endpointURL.String(), header, nil
+}
+
+type websocketCodec struct {
+ *jsonCodec
+ conn *websocket.Conn
+ info PeerInfo
+
+ wg sync.WaitGroup
+ pingReset chan struct{}
+}
+
+func newWebsocketCodec(conn *websocket.Conn, host string, req http.Header) ServerCodec {
+ conn.SetReadLimit(wsMessageSizeLimit)
+ conn.SetPongHandler(func(appData string) error {
+ conn.SetReadDeadline(time.Time{})
+ return nil
+ })
+ wc := &websocketCodec{
+ jsonCodec: NewFuncCodec(conn, conn.WriteJSON, conn.ReadJSON).(*jsonCodec),
+ conn: conn,
+ pingReset: make(chan struct{}, 1),
+ info: PeerInfo{
+ Transport: "ws",
+ RemoteAddr: conn.RemoteAddr().String(),
+ },
+ }
+ // Fill in connection details.
+ wc.info.HTTP.Host = host
+ wc.info.HTTP.Origin = req.Get("Origin")
+ wc.info.HTTP.UserAgent = req.Get("User-Agent")
+ // Start pinger.
+ wc.wg.Add(1)
+ go wc.pingLoop()
+ return wc
+}
+
+func (wc *websocketCodec) close() {
+ wc.jsonCodec.close()
+ wc.wg.Wait()
+}
+
+func (wc *websocketCodec) peerInfo() PeerInfo {
+ return wc.info
+}
+
+func (wc *websocketCodec) writeJSON(ctx context.Context, v interface{}) error {
+ err := wc.jsonCodec.writeJSON(ctx, v)
+ if err == nil {
+ // Notify pingLoop to delay the next idle ping.
+ select {
+ case wc.pingReset <- struct{}{}:
+ default:
+ }
+ }
+ return err
+}
+
+// pingLoop sends periodic ping frames when the connection is idle.
+func (wc *websocketCodec) pingLoop() {
+ var timer = time.NewTimer(wsPingInterval)
+ defer wc.wg.Done()
+ defer timer.Stop()
+
+ for {
+ select {
+ case <-wc.closed():
+ return
+ case <-wc.pingReset:
+ if !timer.Stop() {
+ <-timer.C
+ }
+ timer.Reset(wsPingInterval)
+ case <-timer.C:
+ wc.jsonCodec.encMu.Lock()
+ wc.conn.SetWriteDeadline(time.Now().Add(wsPingWriteTimeout))
+ wc.conn.WriteMessage(websocket.PingMessage, nil)
+ wc.conn.SetReadDeadline(time.Now().Add(wsPongTimeout))
+ wc.jsonCodec.encMu.Unlock()
+ timer.Reset(wsPingInterval)
+ }
+ }
+}
diff --git a/relayer/chainproxy/rpcclient/websocket_test.go b/relayer/chainproxy/rpcclient/websocket_test.go
new file mode 100755
index 0000000000..c746889ba3
--- /dev/null
+++ b/relayer/chainproxy/rpcclient/websocket_test.go
@@ -0,0 +1,416 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rpcclient
+
+import (
+ "context"
+ "errors"
+ "io"
+ "net"
+ "net/http"
+ "net/http/httptest"
+ "net/http/httputil"
+ "net/url"
+ "strings"
+ "sync/atomic"
+ "testing"
+ "time"
+
+ "github.com/gorilla/websocket"
+)
+
+func TestWebsocketClientHeaders(t *testing.T) {
+ t.Parallel()
+
+ endpoint, header, err := wsClientHeaders("wss://testuser:test-PASS_01@example.com:1234", "https://example.com")
+ if err != nil {
+ t.Fatalf("wsGetConfig failed: %s", err)
+ }
+ if endpoint != "wss://example.com:1234" {
+ t.Fatal("User should have been stripped from the URL")
+ }
+ if header.Get("authorization") != "Basic dGVzdHVzZXI6dGVzdC1QQVNTXzAx" {
+ t.Fatal("Basic auth header is incorrect")
+ }
+ if header.Get("origin") != "https://example.com" {
+ t.Fatal("Origin not set")
+ }
+}
+
+// This test checks that the server rejects connections from disallowed origins.
+func TestWebsocketOriginCheck(t *testing.T) {
+ t.Parallel()
+
+ var (
+ srv = newTestServer()
+ httpsrv = httptest.NewServer(srv.WebsocketHandler([]string{"http://example.com"}))
+ wsURL = "ws:" + strings.TrimPrefix(httpsrv.URL, "http:")
+ )
+ defer srv.Stop()
+ defer httpsrv.Close()
+
+ client, err := DialWebsocket(context.Background(), wsURL, "http://ekzample.com")
+ if err == nil {
+ client.Close()
+ t.Fatal("no error for wrong origin")
+ }
+ wantErr := wsHandshakeError{websocket.ErrBadHandshake, "403 Forbidden"}
+ if !errors.Is(err, wantErr) {
+ t.Fatalf("wrong error for wrong origin: %q", err)
+ }
+
+ // Connections without origin header should work.
+ client, err = DialWebsocket(context.Background(), wsURL, "")
+ if err != nil {
+ t.Fatalf("error for empty origin: %v", err)
+ }
+ client.Close()
+}
+
+// This test checks whether calls exceeding the request size limit are rejected.
+func TestWebsocketLargeCall(t *testing.T) {
+ t.Parallel()
+
+ var (
+ srv = newTestServer()
+ httpsrv = httptest.NewServer(srv.WebsocketHandler([]string{"*"}))
+ wsURL = "ws:" + strings.TrimPrefix(httpsrv.URL, "http:")
+ )
+ defer srv.Stop()
+ defer httpsrv.Close()
+
+ client, err := DialWebsocket(context.Background(), wsURL, "")
+ if err != nil {
+ t.Fatalf("can't dial: %v", err)
+ }
+ defer client.Close()
+
+ // This call sends slightly less than the limit and should work.
+ var result echoResult
+ arg := strings.Repeat("x", maxRequestContentLength-200)
+ if err := client.Call(&result, "test_echo", arg, 1); err != nil {
+ t.Fatalf("valid call didn't work: %v", err)
+ }
+ if result.String != arg {
+ t.Fatal("wrong string echoed")
+ }
+
+ // This call sends twice the allowed size and shouldn't work.
+ arg = strings.Repeat("x", maxRequestContentLength*2)
+ err = client.Call(&result, "test_echo", arg)
+ if err == nil {
+ t.Fatal("no error for too large call")
+ }
+}
+
+func TestWebsocketPeerInfo(t *testing.T) {
+ var (
+ s = newTestServer()
+ ts = httptest.NewServer(s.WebsocketHandler([]string{"origin.example.com"}))
+ tsurl = "ws:" + strings.TrimPrefix(ts.URL, "http:")
+ )
+ defer s.Stop()
+ defer ts.Close()
+
+ ctx := context.Background()
+ c, err := DialWebsocket(ctx, tsurl, "origin.example.com")
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ // Request peer information.
+ var connInfo PeerInfo
+ if err := c.Call(&connInfo, "test_peerInfo"); err != nil {
+ t.Fatal(err)
+ }
+
+ if connInfo.RemoteAddr == "" {
+ t.Error("RemoteAddr not set")
+ }
+ if connInfo.Transport != "ws" {
+ t.Errorf("wrong Transport %q", connInfo.Transport)
+ }
+ if connInfo.HTTP.UserAgent != "Go-http-client/1.1" {
+ t.Errorf("wrong HTTP.UserAgent %q", connInfo.HTTP.UserAgent)
+ }
+ if connInfo.HTTP.Origin != "origin.example.com" {
+ t.Errorf("wrong HTTP.Origin %q", connInfo.HTTP.UserAgent)
+ }
+}
+
+// This test checks that client handles WebSocket ping frames correctly.
+func TestClientWebsocketPing(t *testing.T) {
+ t.Parallel()
+
+ var (
+ sendPing = make(chan struct{})
+ server = wsPingTestServer(t, sendPing)
+ ctx, cancel = context.WithTimeout(context.Background(), 1*time.Second)
+ )
+ defer cancel()
+ defer server.Shutdown(ctx)
+
+ client, err := DialContext(ctx, "ws://"+server.Addr)
+ if err != nil {
+ t.Fatalf("client dial error: %v", err)
+ }
+ defer client.Close()
+
+ resultChan := make(chan int)
+ sub, err := client.EthSubscribe(ctx, resultChan, "foo")
+ if err != nil {
+ t.Fatalf("client subscribe error: %v", err)
+ }
+ // Note: Unsubscribe is not called on this subscription because the mockup
+ // server can't handle the request.
+
+ // Wait for the context's deadline to be reached before proceeding.
+ // This is important for reproducing https://github.com/ethereum/go-ethereum/issues/19798
+ <-ctx.Done()
+ close(sendPing)
+
+ // Wait for the subscription result.
+ timeout := time.NewTimer(5 * time.Second)
+ defer timeout.Stop()
+ for {
+ select {
+ case err := <-sub.Err():
+ t.Error("client subscription error:", err)
+ case result := <-resultChan:
+ t.Log("client got result:", result)
+ return
+ case <-timeout.C:
+ t.Error("didn't get any result within the test timeout")
+ return
+ }
+ }
+}
+
+// This checks that the websocket transport can deal with large messages.
+func TestClientWebsocketLargeMessage(t *testing.T) {
+ var (
+ srv = NewServer()
+ httpsrv = httptest.NewServer(srv.WebsocketHandler(nil))
+ wsURL = "ws:" + strings.TrimPrefix(httpsrv.URL, "http:")
+ )
+ defer srv.Stop()
+ defer httpsrv.Close()
+
+ respLength := wsMessageSizeLimit - 50
+ srv.RegisterName("test", largeRespService{respLength})
+
+ c, err := DialWebsocket(context.Background(), wsURL, "")
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ var r string
+ if err := c.Call(&r, "test_largeResp"); err != nil {
+ t.Fatal("call failed:", err)
+ }
+ if len(r) != respLength {
+ t.Fatalf("response has wrong length %d, want %d", len(r), respLength)
+ }
+}
+
+func TestClientWebsocketSevered(t *testing.T) {
+ t.Parallel()
+
+ var (
+ server = wsPingTestServer(t, nil)
+ ctx = context.Background()
+ )
+ defer server.Shutdown(ctx)
+
+ u, err := url.Parse("http://" + server.Addr)
+ if err != nil {
+ t.Fatal(err)
+ }
+ rproxy := httputil.NewSingleHostReverseProxy(u)
+ var severable *severableReadWriteCloser
+ rproxy.ModifyResponse = func(response *http.Response) error {
+ severable = &severableReadWriteCloser{ReadWriteCloser: response.Body.(io.ReadWriteCloser)}
+ response.Body = severable
+ return nil
+ }
+ frontendProxy := httptest.NewServer(rproxy)
+ defer frontendProxy.Close()
+
+ wsURL := "ws:" + strings.TrimPrefix(frontendProxy.URL, "http:")
+ client, err := DialWebsocket(ctx, wsURL, "")
+ if err != nil {
+ t.Fatalf("client dial error: %v", err)
+ }
+ defer client.Close()
+
+ resultChan := make(chan int)
+ sub, err := client.EthSubscribe(ctx, resultChan, "foo")
+ if err != nil {
+ t.Fatalf("client subscribe error: %v", err)
+ }
+
+ // sever the connection
+ severable.Sever()
+
+ // Wait for subscription error.
+ timeout := time.NewTimer(3 * wsPingInterval)
+ defer timeout.Stop()
+ for {
+ select {
+ case err := <-sub.Err():
+ t.Log("client subscription error:", err)
+ return
+ case result := <-resultChan:
+ t.Error("unexpected result:", result)
+ return
+ case <-timeout.C:
+ t.Error("didn't get any error within the test timeout")
+ return
+ }
+ }
+}
+
+// wsPingTestServer runs a WebSocket server which accepts a single subscription request.
+// When a value arrives on sendPing, the server sends a ping frame, waits for a matching
+// pong and finally delivers a single subscription result.
+func wsPingTestServer(t *testing.T, sendPing <-chan struct{}) *http.Server {
+ var srv http.Server
+ shutdown := make(chan struct{})
+ srv.RegisterOnShutdown(func() {
+ close(shutdown)
+ })
+ srv.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ // Upgrade to WebSocket.
+ upgrader := websocket.Upgrader{
+ CheckOrigin: func(r *http.Request) bool { return true },
+ }
+ conn, err := upgrader.Upgrade(w, r, nil)
+ if err != nil {
+ t.Errorf("server WS upgrade error: %v", err)
+ return
+ }
+ defer conn.Close()
+
+ // Handle the connection.
+ wsPingTestHandler(t, conn, shutdown, sendPing)
+ })
+
+ // Start the server.
+ listener, err := net.Listen("tcp", "127.0.0.1:0")
+ if err != nil {
+ t.Fatal("can't listen:", err)
+ }
+ srv.Addr = listener.Addr().String()
+ go srv.Serve(listener)
+ return &srv
+}
+
+func wsPingTestHandler(t *testing.T, conn *websocket.Conn, shutdown, sendPing <-chan struct{}) {
+ // Canned responses for the eth_subscribe call in TestClientWebsocketPing.
+ const (
+ subResp = `{"jsonrpc":"2.0","id":1,"result":"0x00"}`
+ subNotify = `{"jsonrpc":"2.0","method":"eth_subscription","params":{"subscription":"0x00","result":1}}`
+ )
+
+ // Handle subscribe request.
+ if _, _, err := conn.ReadMessage(); err != nil {
+ t.Errorf("server read error: %v", err)
+ return
+ }
+ if err := conn.WriteMessage(websocket.TextMessage, []byte(subResp)); err != nil {
+ t.Errorf("server write error: %v", err)
+ return
+ }
+
+ // Read from the connection to process control messages.
+ var pongCh = make(chan string)
+ conn.SetPongHandler(func(d string) error {
+ t.Logf("server got pong: %q", d)
+ pongCh <- d
+ return nil
+ })
+ go func() {
+ for {
+ typ, msg, err := conn.ReadMessage()
+ if err != nil {
+ return
+ }
+ t.Logf("server got message (%d): %q", typ, msg)
+ }
+ }()
+
+ // Write messages.
+ var (
+ wantPong string
+ timer = time.NewTimer(0)
+ )
+ defer timer.Stop()
+ <-timer.C
+ for {
+ select {
+ case _, open := <-sendPing:
+ if !open {
+ sendPing = nil
+ }
+ t.Logf("server sending ping")
+ conn.WriteMessage(websocket.PingMessage, []byte("ping"))
+ wantPong = "ping"
+ case data := <-pongCh:
+ if wantPong == "" {
+ t.Errorf("unexpected pong")
+ } else if data != wantPong {
+ t.Errorf("got pong with wrong data %q", data)
+ }
+ wantPong = ""
+ timer.Reset(200 * time.Millisecond)
+ case <-timer.C:
+ t.Logf("server sending response")
+ conn.WriteMessage(websocket.TextMessage, []byte(subNotify))
+ case <-shutdown:
+ conn.Close()
+ return
+ }
+ }
+}
+
+// severableReadWriteCloser wraps an io.ReadWriteCloser and provides a Sever() method to drop writes and read empty.
+type severableReadWriteCloser struct {
+ io.ReadWriteCloser
+ severed int32 // atomic
+}
+
+func (s *severableReadWriteCloser) Sever() {
+ atomic.StoreInt32(&s.severed, 1)
+}
+
+func (s *severableReadWriteCloser) Read(p []byte) (n int, err error) {
+ if atomic.LoadInt32(&s.severed) > 0 {
+ return 0, nil
+ }
+ return s.ReadWriteCloser.Read(p)
+}
+
+func (s *severableReadWriteCloser) Write(p []byte) (n int, err error) {
+ if atomic.LoadInt32(&s.severed) > 0 {
+ return len(p), nil
+ }
+ return s.ReadWriteCloser.Write(p)
+}
+
+func (s *severableReadWriteCloser) Close() error {
+ return s.ReadWriteCloser.Close()
+}
diff --git a/relayer/test_client.go b/relayer/test_client.go
index 4d2ab240fe..762a1191cc 100644
--- a/relayer/test_client.go
+++ b/relayer/test_client.go
@@ -73,7 +73,7 @@ func TestClient(
testErrors = testclients.EthTests(ctx, chainProxy, privKey)
case "COS1":
testErrors = testclients.TerraTests(ctx, chainProxy, privKey, apiInterface)
- case "COS3":
+ case "COS3", "COS4":
testErrors = testclients.OsmosisTests(ctx, chainProxy, privKey, apiInterface)
case "LAV1":
testErrors = testclients.LavaTests(ctx, chainProxy, privKey, apiInterface, sentry, clientCtx)