94 lines
3.1 KiB
Go
94 lines
3.1 KiB
Go
// VulcanizeDB
|
|
// Copyright © 2019 Vulcanize
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
|
|
// This program 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 Affero General Public License for more details.
|
|
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package client
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"reflect"
|
|
|
|
"github.com/ethereum/go-ethereum/rpc"
|
|
)
|
|
|
|
// RPCClient is a wrapper around the geth RPC client
|
|
type RPCClient struct {
|
|
client *rpc.Client
|
|
ipcPath string
|
|
}
|
|
|
|
// BatchElem is a struct to hold the elements of a BatchCall
|
|
type BatchElem struct {
|
|
Method string
|
|
Args []interface{}
|
|
Result interface{}
|
|
Error error
|
|
}
|
|
|
|
// NewRPCClient creates a new RpcClient
|
|
func NewRPCClient(client *rpc.Client, ipcPath string) RPCClient {
|
|
return RPCClient{
|
|
client: client,
|
|
ipcPath: ipcPath,
|
|
}
|
|
}
|
|
|
|
// CallContext makes an rpc method call with the provided context and arguments
|
|
func (client RPCClient) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error {
|
|
//If an empty interface (or other nil object) is passed to CallContext, when the JSONRPC message is created the params will
|
|
//be interpreted as [null]. This seems to work fine for most of the ethereum clients (which presumably ignore a null parameter.
|
|
//Ganache however does not ignore it, and throws an 'Incorrect number of arguments' error.
|
|
if args == nil {
|
|
return client.client.CallContext(ctx, result, method)
|
|
}
|
|
return client.client.CallContext(ctx, result, method, args...)
|
|
}
|
|
|
|
func (client RPCClient) IpcPath() string {
|
|
return client.ipcPath
|
|
}
|
|
|
|
func (client RPCClient) SupportedModules() (map[string]string, error) {
|
|
return client.client.SupportedModules()
|
|
}
|
|
|
|
func (client RPCClient) BatchCall(batch []BatchElem) error {
|
|
var rpcBatch []rpc.BatchElem
|
|
for _, batchElem := range batch {
|
|
var newBatchElem = rpc.BatchElem{
|
|
Result: batchElem.Result,
|
|
Method: batchElem.Method,
|
|
Args: batchElem.Args,
|
|
Error: batchElem.Error,
|
|
}
|
|
rpcBatch = append(rpcBatch, newBatchElem)
|
|
}
|
|
return client.client.BatchCall(rpcBatch)
|
|
}
|
|
|
|
// Subscribe subscribes to an rpc "namespace_subscribe" subscription with the given channel
|
|
// The first argument needs to be the method we wish to invoke
|
|
func (client RPCClient) Subscribe(namespace string, payloadChan interface{}, args ...interface{}) (*rpc.ClientSubscription, error) {
|
|
chanVal := reflect.ValueOf(payloadChan)
|
|
if chanVal.Kind() != reflect.Chan || chanVal.Type().ChanDir()&reflect.SendDir == 0 {
|
|
return nil, errors.New("second argument to Subscribe must be a writable channel")
|
|
}
|
|
if chanVal.IsNil() {
|
|
return nil, errors.New("channel given to Subscribe must not be nil")
|
|
}
|
|
return client.client.Subscribe(context.Background(), namespace, payloadChan, args...)
|
|
}
|