mirror of
https://github.com/codex-storage/nim-json-rpc.git
synced 2025-02-22 07:58:22 +00:00
Rename eth-rpc to rpc
This commit is contained in:
coffeepots
parent
5a5032a904
commit
9f05f63054
@ -1,212 +0,0 @@
|
||||
import tables, json, macros
|
||||
import asyncdispatch2
|
||||
import jsonmarshal
|
||||
|
||||
type
|
||||
RpcClient* = ref object
|
||||
transp: StreamTransport
|
||||
awaiting: Table[string, Future[Response]]
|
||||
address: TransportAddress
|
||||
nextId: int64
|
||||
Response* = tuple[error: bool, result: JsonNode]
|
||||
|
||||
const maxRequestLength = 1024 * 128
|
||||
|
||||
proc newRpcClient*(): RpcClient =
|
||||
## Creates a new ``RpcClient`` instance.
|
||||
result = RpcClient(awaiting: initTable[string, Future[Response]](), nextId: 1)
|
||||
|
||||
proc call*(self: RpcClient, name: string,
|
||||
params: JsonNode): Future[Response] {.async.} =
|
||||
## Remotely calls the specified RPC method.
|
||||
let id = $self.nextId
|
||||
self.nextId.inc
|
||||
var msg = $ %{"jsonrpc": %"2.0", "method": %name, "params": params,
|
||||
"id": %id} & "\c\l"
|
||||
let res = await self.transp.write(msg)
|
||||
# TODO: Add actions when not full packet was send, e.g. disconnect peer.
|
||||
assert(res == len(msg))
|
||||
|
||||
# completed by processMessage.
|
||||
var newFut = newFuture[Response]()
|
||||
# add to awaiting responses
|
||||
self.awaiting[id] = newFut
|
||||
result = await newFut
|
||||
|
||||
template handleRaise[T](fut: Future[T], errType: typedesc, msg: string) =
|
||||
# complete future before raising
|
||||
fut.complete((true, %msg))
|
||||
raise newException(errType, msg)
|
||||
|
||||
macro checkGet(node: JsonNode, fieldName: string,
|
||||
jKind: static[JsonNodeKind]): untyped =
|
||||
let n = genSym(ident = "n") #`node`{`fieldName`}
|
||||
result = quote:
|
||||
let `n` = `node`{`fieldname`}
|
||||
if `n`.isNil or `n`.kind == JNull:
|
||||
raise newException(ValueError,
|
||||
"Message is missing required field \"" & `fieldName` & "\"")
|
||||
if `n`.kind != `jKind`.JsonNodeKind:
|
||||
raise newException(ValueError,
|
||||
"Expected " & $(`jKind`.JsonNodeKind) & ", got " & $`n`.kind)
|
||||
case jKind
|
||||
of JBool: result.add(quote do: `n`.getBool)
|
||||
of JInt: result.add(quote do: `n`.getInt)
|
||||
of JString: result.add(quote do: `n`.getStr)
|
||||
of JFloat: result.add(quote do: `n`.getFloat)
|
||||
of JObject: result.add(quote do: `n`.getObject)
|
||||
else: discard
|
||||
|
||||
proc processMessage(self: RpcClient, line: string) =
|
||||
let node = parseJson(line)
|
||||
|
||||
# TODO: Use more appropriate exception objects
|
||||
let id = checkGet(node, "id", JString)
|
||||
if not self.awaiting.hasKey(id):
|
||||
raise newException(ValueError,
|
||||
"Cannot find message id \"" & node["id"].str & "\"")
|
||||
|
||||
let version = checkGet(node, "jsonrpc", JString)
|
||||
if version != "2.0":
|
||||
self.awaiting[id].handleRaise(ValueError,
|
||||
"Unsupported version of JSON, expected 2.0, received \"" & version & "\"")
|
||||
|
||||
let errorNode = node{"error"}
|
||||
if errorNode.isNil or errorNode.kind == JNull:
|
||||
var res = node{"result"}
|
||||
if not res.isNil:
|
||||
self.awaiting[id].complete((false, res))
|
||||
self.awaiting.del(id)
|
||||
# TODO: actions on unable find result node
|
||||
else:
|
||||
self.awaiting[id].complete((true, errorNode))
|
||||
self.awaiting.del(id)
|
||||
|
||||
proc connect*(self: RpcClient, address: string, port: Port): Future[void]
|
||||
|
||||
proc processData(self: RpcClient) {.async.} =
|
||||
while true:
|
||||
let line = await self.transp.readLine(maxRequestLength)
|
||||
if line == "":
|
||||
# transmission ends
|
||||
self.transp.close()
|
||||
break
|
||||
|
||||
processMessage(self, line)
|
||||
# async loop reconnection and waiting
|
||||
self.transp = await connect(self.address)
|
||||
|
||||
proc connect*(self: RpcClient, address: string, port: Port) {.async.} =
|
||||
# TODO: `address` hostname can be resolved to many IP addresses, we are using
|
||||
# first one, but maybe it would be better to iterate over all IP addresses
|
||||
# and try to establish connection until it will not be established.
|
||||
let addresses = resolveTAddress(address, port)
|
||||
self.transp = await connect(addresses[0])
|
||||
self.address = addresses[0]
|
||||
asyncCheck processData(self)
|
||||
|
||||
proc createRpcProc(procName, parameters, callBody: NimNode): NimNode =
|
||||
# parameters come as a tree
|
||||
var paramList = newSeq[NimNode]()
|
||||
for p in parameters: paramList.add(p)
|
||||
|
||||
# build proc
|
||||
result = newProc(procName, paramList, callBody)
|
||||
# make proc async
|
||||
result.addPragma ident"async"
|
||||
# export this proc
|
||||
result[0] = nnkPostFix.newTree(ident"*", newIdentNode($procName))
|
||||
|
||||
proc toJsonArray(parameters: NimNode): NimNode =
|
||||
# outputs an array of jsonified parameters
|
||||
# ie; %[%a, %b, %c]
|
||||
parameters.expectKind nnkFormalParams
|
||||
var items = newNimNode(nnkBracket)
|
||||
for i in 2 ..< parameters.len:
|
||||
let curParam = parameters[i][0]
|
||||
if curParam.kind != nnkEmpty:
|
||||
items.add(nnkPrefix.newTree(ident"%", curParam))
|
||||
result = nnkPrefix.newTree(bindSym("%", brForceOpen), items)
|
||||
|
||||
proc createRpcFromSig*(rpcDecl: NimNode): NimNode =
|
||||
# Each input parameter in the rpc signature is converted
|
||||
# to json with `%`.
|
||||
# Return types are then converted back to native Nim types.
|
||||
let iJsonNode = newIdentNode("JsonNode")
|
||||
|
||||
var parameters = rpcDecl.findChild(it.kind == nnkFormalParams).copy
|
||||
# ensure we have at least space for a return parameter
|
||||
if parameters.isNil or parameters.kind == nnkEmpty or parameters.len == 0:
|
||||
parameters = nnkFormalParams.newTree(iJsonNode)
|
||||
|
||||
let
|
||||
procName = rpcDecl.name
|
||||
pathStr = $procName
|
||||
returnType =
|
||||
# if no return type specified, defaults to JsonNode
|
||||
if parameters[0].kind == nnkEmpty: iJsonNode
|
||||
else: parameters[0]
|
||||
customReturnType = returnType != iJsonNode
|
||||
|
||||
# insert rpc client as first parameter
|
||||
parameters.insert(1, nnkIdentDefs.newTree(ident"client", ident"RpcClient",
|
||||
newEmptyNode()))
|
||||
|
||||
let
|
||||
# variable used to send json to the server
|
||||
jsonParamIdent = genSym(nskVar, "jsonParam")
|
||||
# json array of marshalled parameters
|
||||
jsonParamArray = parameters.toJsonArray()
|
||||
var
|
||||
# populate json params - even rpcs with no parameters have an empty json
|
||||
# array node sent
|
||||
callBody = newStmtList().add(quote do:
|
||||
var `jsonParamIdent` = `jsonParamArray`
|
||||
)
|
||||
|
||||
# convert return type to Future
|
||||
parameters[0] = nnkBracketExpr.newTree(ident"Future", returnType)
|
||||
# create rpc proc
|
||||
result = createRpcProc(procName, parameters, callBody)
|
||||
|
||||
let
|
||||
# temporary variable to hold `Response` from rpc call
|
||||
rpcResult = genSym(nskLet, "res")
|
||||
clientIdent = newIdentNode("client")
|
||||
# proc return variable
|
||||
procRes = ident"result"
|
||||
# actual return value, `rpcResult`.result
|
||||
jsonRpcResult = nnkDotExpr.newTree(rpcResult, newIdentNode("result"))
|
||||
|
||||
# perform rpc call
|
||||
callBody.add(quote do:
|
||||
# `rpcResult` is of type `Response`
|
||||
let `rpcResult` = await `clientIdent`.call(`pathStr`, `jsonParamIdent`)
|
||||
if `rpcResult`.error: raise newException(ValueError, $`rpcResult`.result)
|
||||
)
|
||||
|
||||
if customReturnType:
|
||||
# marshal json to native Nim type
|
||||
callBody.add(jsonToNim(procRes, returnType, jsonRpcResult, "result"))
|
||||
else:
|
||||
# native json expected so no work
|
||||
callBody.add(quote do:
|
||||
`procRes` = `rpcResult`.result
|
||||
)
|
||||
when defined(nimDumpRpcs):
|
||||
echo pathStr, ":\n", result.repr
|
||||
|
||||
proc processRpcSigs(parsedCode: NimNode): NimNode =
|
||||
result = newStmtList()
|
||||
|
||||
for line in parsedCode:
|
||||
if line.kind == nnkProcDef:
|
||||
var procDef = createRpcFromSig(line)
|
||||
result.add(procDef)
|
||||
|
||||
macro createRpcSigs*(filePath: static[string]): untyped =
|
||||
## Takes a file of forward declarations in Nim and builds them into RPC
|
||||
## calls, based on their parameters.
|
||||
## Inputs are marshalled to json, and results are put into the signature's
|
||||
## Nim type.
|
||||
result = processRpcSigs(staticRead($filePath).parseStmt())
|
||||
@ -1,354 +0,0 @@
|
||||
import json, tables, strutils, options, macros #, chronicles
|
||||
import asyncdispatch2
|
||||
import jsonmarshal
|
||||
|
||||
export asyncdispatch2, json, jsonmarshal
|
||||
|
||||
# Temporarily disable logging
|
||||
macro debug(body: varargs[untyped]): untyped = newStmtList()
|
||||
macro info(body: varargs[untyped]): untyped = newStmtList()
|
||||
macro error(body: varargs[untyped]): untyped = newStmtList()
|
||||
|
||||
#logScope:
|
||||
# topics = "RpcServer"
|
||||
|
||||
type
|
||||
RpcJsonError* = enum rjeInvalidJson, rjeVersionError, rjeNoMethod, rjeNoId
|
||||
|
||||
RpcJsonErrorContainer* = tuple[err: RpcJsonError, msg: string]
|
||||
|
||||
# Procedure signature accepted as an RPC call by server
|
||||
RpcProc* = proc (params: JsonNode): Future[JsonNode]
|
||||
|
||||
RpcServer* = ref object
|
||||
servers*: seq[StreamServer]
|
||||
procs*: TableRef[string, RpcProc]
|
||||
|
||||
RpcProcError* = ref object of Exception
|
||||
code*: int
|
||||
data*: JsonNode
|
||||
|
||||
RpcBindError* = object of Exception
|
||||
RpcAddressUnresolvableError* = object of Exception
|
||||
|
||||
const
|
||||
JSON_PARSE_ERROR* = -32700
|
||||
INVALID_REQUEST* = -32600
|
||||
METHOD_NOT_FOUND* = -32601
|
||||
INVALID_PARAMS* = -32602
|
||||
INTERNAL_ERROR* = -32603
|
||||
SERVER_ERROR* = -32000
|
||||
|
||||
maxRequestLength = 1024 * 128
|
||||
|
||||
jsonErrorMessages*: array[RpcJsonError, (int, string)] =
|
||||
[
|
||||
(JSON_PARSE_ERROR, "Invalid JSON"),
|
||||
(INVALID_REQUEST, "JSON 2.0 required"),
|
||||
(INVALID_REQUEST, "No method requested"),
|
||||
(INVALID_REQUEST, "No id specified")
|
||||
]
|
||||
|
||||
# Utility functions
|
||||
# TODO: Move outside server
|
||||
func `%`*(p: Port): JsonNode = %(p.int)
|
||||
|
||||
# Json state checking
|
||||
|
||||
template jsonValid*(jsonString: string, node: var JsonNode): (bool, string) =
|
||||
var
|
||||
valid = true
|
||||
msg = ""
|
||||
try: node = parseJson(line)
|
||||
except:
|
||||
valid = false
|
||||
msg = getCurrentExceptionMsg()
|
||||
debug "Cannot process json", json = jsonString, msg = msg
|
||||
(valid, msg)
|
||||
|
||||
proc checkJsonErrors*(line: string,
|
||||
node: var JsonNode): Option[RpcJsonErrorContainer] =
|
||||
## Tries parsing line into node, if successful checks required fields
|
||||
## Returns: error state or none
|
||||
let res = jsonValid(line, node)
|
||||
if not res[0]:
|
||||
return some((rjeInvalidJson, res[1]))
|
||||
if not node.hasKey("id"):
|
||||
return some((rjeNoId, ""))
|
||||
if node{"jsonrpc"} != %"2.0":
|
||||
return some((rjeVersionError, ""))
|
||||
if not node.hasKey("method"):
|
||||
return some((rjeNoMethod, ""))
|
||||
return none(RpcJsonErrorContainer)
|
||||
|
||||
# Json reply wrappers
|
||||
|
||||
proc wrapReply*(id: JsonNode, value: JsonNode, error: JsonNode): string =
|
||||
let node = %{"jsonrpc": %"2.0", "result": value, "error": error, "id": id}
|
||||
return $node & "\c\l"
|
||||
|
||||
proc sendError*(client: StreamTransport, code: int, msg: string, id: JsonNode,
|
||||
data: JsonNode = newJNull()) {.async.} =
|
||||
## Send error message to client
|
||||
let error = %{"code": %(code), "id": id, "message": %msg, "data": data}
|
||||
debug "Error generated", error = error, id = id
|
||||
var res = wrapReply(id, newJNull(), error)
|
||||
result = client.write(res)
|
||||
|
||||
proc sendJsonError*(state: RpcJsonError, client: StreamTransport, id: JsonNode,
|
||||
data = newJNull()) {.async.} =
|
||||
## Send client response for invalid json state
|
||||
let errMsgs = jsonErrorMessages[state]
|
||||
await client.sendError(errMsgs[0], errMsgs[1], id, data)
|
||||
|
||||
# Server message processing
|
||||
proc processMessage(server: RpcServer, client: StreamTransport,
|
||||
line: string) {.async.} =
|
||||
var
|
||||
node: JsonNode
|
||||
# set up node and/or flag errors
|
||||
jsonErrorState = checkJsonErrors(line, node)
|
||||
|
||||
if jsonErrorState.isSome:
|
||||
let errState = jsonErrorState.get
|
||||
var id =
|
||||
if errState.err == rjeInvalidJson or errState.err == rjeNoId:
|
||||
newJNull()
|
||||
else:
|
||||
node["id"]
|
||||
await errState.err.sendJsonError(client, id, %errState.msg)
|
||||
else:
|
||||
let
|
||||
methodName = node["method"].str
|
||||
id = node["id"]
|
||||
|
||||
if not server.procs.hasKey(methodName):
|
||||
await client.sendError(METHOD_NOT_FOUND, "Method not found", %id,
|
||||
%(methodName & " is not a registered method."))
|
||||
else:
|
||||
let callRes = await server.procs[methodName](node["params"])
|
||||
var res = wrapReply(id, callRes, newJNull())
|
||||
discard await client.write(res)
|
||||
|
||||
proc processClient(server: StreamServer, client: StreamTransport) {.async, gcsafe.} =
|
||||
var rpc = getUserData[RpcServer](server)
|
||||
while true:
|
||||
let line = await client.readLine(maxRequestLength)
|
||||
if line == "":
|
||||
client.close()
|
||||
break
|
||||
|
||||
debug "Processing client", addresss = client.remoteAddress(), line
|
||||
|
||||
let future = processMessage(rpc, client, line)
|
||||
yield future
|
||||
if future.failed:
|
||||
if future.readError of RpcProcError:
|
||||
let err = future.readError.RpcProcError
|
||||
await client.sendError(err.code, err.msg, err.data)
|
||||
elif future.readError of ValueError:
|
||||
let err = future.readError[].ValueError
|
||||
await client.sendError(INVALID_PARAMS, err.msg, %"")
|
||||
else:
|
||||
await client.sendError(SERVER_ERROR,
|
||||
"Error: Unknown error occurred", %"")
|
||||
|
||||
proc newRpcServer*(addresses: openarray[TransportAddress]): RpcServer =
|
||||
## Create new server and assign it to addresses ``addresses``.
|
||||
result = RpcServer()
|
||||
result.procs = newTable[string, RpcProc]()
|
||||
result.servers = newSeq[StreamServer]()
|
||||
|
||||
for item in addresses:
|
||||
try:
|
||||
info "Creating server on ", address = $item
|
||||
var server = createStreamServer(item, processClient, {ReuseAddr},
|
||||
udata = result)
|
||||
result.servers.add(server)
|
||||
except:
|
||||
error "Failed to create server", address = $item, message = getCurrentExceptionMsg()
|
||||
|
||||
if len(result.servers) == 0:
|
||||
# Server was not bound, critical error.
|
||||
# TODO: Custom RpcException error
|
||||
raise newException(RpcBindError, "Unable to create server!")
|
||||
|
||||
proc newRpcServer*(addresses: openarray[string]): RpcServer =
|
||||
## Create new server and assign it to addresses ``addresses``.
|
||||
var
|
||||
tas4: seq[TransportAddress]
|
||||
tas6: seq[TransportAddress]
|
||||
baddrs: seq[TransportAddress]
|
||||
|
||||
for a in addresses:
|
||||
# Attempt to resolve `address` for IPv4 address space.
|
||||
try:
|
||||
tas4 = resolveTAddress(a, IpAddressFamily.IPv4)
|
||||
except:
|
||||
discard
|
||||
|
||||
# Attempt to resolve `address` for IPv6 address space.
|
||||
try:
|
||||
tas6 = resolveTAddress(a, IpAddressFamily.IPv6)
|
||||
except:
|
||||
discard
|
||||
|
||||
for r in tas4:
|
||||
baddrs.add(r)
|
||||
for r in tas6:
|
||||
baddrs.add(r)
|
||||
|
||||
if len(baddrs) == 0:
|
||||
# Addresses could not be resolved, critical error.
|
||||
raise newException(RpcAddressUnresolvableError, "Unable to get address!")
|
||||
|
||||
result = newRpcServer(baddrs)
|
||||
|
||||
proc newRpcServer*(address = "localhost", port: Port = Port(8545)): RpcServer =
|
||||
var
|
||||
tas4: seq[TransportAddress]
|
||||
tas6: seq[TransportAddress]
|
||||
|
||||
# Attempt to resolve `address` for IPv4 address space.
|
||||
try:
|
||||
tas4 = resolveTAddress(address, port, IpAddressFamily.IPv4)
|
||||
except:
|
||||
discard
|
||||
|
||||
# Attempt to resolve `address` for IPv6 address space.
|
||||
try:
|
||||
tas6 = resolveTAddress(address, port, IpAddressFamily.IPv6)
|
||||
except:
|
||||
discard
|
||||
|
||||
if len(tas4) == 0 and len(tas6) == 0:
|
||||
# Address was not resolved, critical error.
|
||||
raise newException(RpcAddressUnresolvableError,
|
||||
"Address " & address & " could not be resolved!")
|
||||
|
||||
result = RpcServer()
|
||||
result.procs = newTable[string, RpcProc]()
|
||||
result.servers = newSeq[StreamServer]()
|
||||
for item in tas4:
|
||||
try:
|
||||
info "Creating server for address", ip4address = $item
|
||||
var server = createStreamServer(item, processClient, {ReuseAddr},
|
||||
udata = result)
|
||||
result.servers.add(server)
|
||||
except:
|
||||
error "Failed to create server for address", address = $item
|
||||
|
||||
for item in tas6:
|
||||
try:
|
||||
info "Server created", ip6address = $item
|
||||
var server = createStreamServer(item, processClient, {ReuseAddr},
|
||||
udata = result)
|
||||
result.servers.add(server)
|
||||
except:
|
||||
error "Failed to create server", address = $item
|
||||
|
||||
if len(result.servers) == 0:
|
||||
# Server was not bound, critical error.
|
||||
raise newException(RpcBindError,
|
||||
"Could not setup server on " & address & ":" & $int(port))
|
||||
|
||||
proc start*(server: RpcServer) =
|
||||
## Start the RPC server.
|
||||
for item in server.servers:
|
||||
item.start()
|
||||
|
||||
proc stop*(server: RpcServer) =
|
||||
## Stop the RPC server.
|
||||
for item in server.servers:
|
||||
item.stop()
|
||||
|
||||
proc close*(server: RpcServer) =
|
||||
## Cleanup resources of RPC server.
|
||||
for item in server.servers:
|
||||
item.close()
|
||||
|
||||
# Server registration and RPC generation
|
||||
|
||||
proc register*(server: RpcServer, name: string, rpc: RpcProc) =
|
||||
## Add a name/code pair to the RPC server.
|
||||
server.procs[name] = rpc
|
||||
|
||||
proc unRegisterAll*(server: RpcServer) =
|
||||
# Remove all remote procedure calls from this server.
|
||||
server.procs.clear
|
||||
|
||||
proc makeProcName(s: string): string =
|
||||
result = ""
|
||||
for c in s:
|
||||
if c.isAlphaNumeric: result.add c
|
||||
|
||||
proc hasReturnType(params: NimNode): bool =
|
||||
if params != nil and params.len > 0 and params[0] != nil and
|
||||
params[0].kind != nnkEmpty:
|
||||
result = true
|
||||
|
||||
macro rpc*(server: RpcServer, path: string, body: untyped): untyped =
|
||||
## Define a remote procedure call.
|
||||
## Input and return parameters are defined using the ``do`` notation.
|
||||
## For example:
|
||||
## .. code-block:: nim
|
||||
## myServer.rpc("path") do(param1: int, param2: float) -> string:
|
||||
## result = $param1 & " " & $param2
|
||||
## ```
|
||||
## Input parameters are automatically marshalled from json to Nim types,
|
||||
## and output parameters are automatically marshalled to json for transport.
|
||||
result = newStmtList()
|
||||
let
|
||||
parameters = body.findChild(it.kind == nnkFormalParams)
|
||||
# all remote calls have a single parameter: `params: JsonNode`
|
||||
paramsIdent = newIdentNode"params"
|
||||
# procs are generated from the stripped path
|
||||
pathStr = $path
|
||||
# strip non alphanumeric
|
||||
procNameStr = pathStr.makeProcName
|
||||
# public rpc proc
|
||||
procName = newIdentNode(procNameStr)
|
||||
# when parameters present: proc that contains our rpc body
|
||||
doMain = newIdentNode(procNameStr & "DoMain")
|
||||
# async result
|
||||
res = newIdentNode("result")
|
||||
var
|
||||
setup = jsonToNim(parameters, paramsIdent)
|
||||
procBody = if body.kind == nnkStmtList: body else: body.body
|
||||
|
||||
if parameters.hasReturnType:
|
||||
let returnType = parameters[0]
|
||||
|
||||
# delegate async proc allows return and setting of result as native type
|
||||
result.add(quote do:
|
||||
proc `doMain`(`paramsIdent`: JsonNode): Future[`returnType`] {.async.} =
|
||||
`setup`
|
||||
`procBody`
|
||||
)
|
||||
|
||||
if returnType == ident"JsonNode":
|
||||
# `JsonNode` results don't need conversion
|
||||
result.add( quote do:
|
||||
proc `procName`(`paramsIdent`: JsonNode): Future[JsonNode] {.async.} =
|
||||
`res` = await `doMain`(`paramsIdent`)
|
||||
)
|
||||
else:
|
||||
result.add(quote do:
|
||||
proc `procName`(`paramsIdent`: JsonNode): Future[JsonNode] {.async.} =
|
||||
`res` = %await `doMain`(`paramsIdent`)
|
||||
)
|
||||
else:
|
||||
# no return types, inline contents
|
||||
result.add(quote do:
|
||||
proc `procName`(`paramsIdent`: JsonNode): Future[JsonNode] {.async.} =
|
||||
`setup`
|
||||
`procBody`
|
||||
)
|
||||
result.add( quote do:
|
||||
`server`.register(`path`, `procName`)
|
||||
)
|
||||
|
||||
when defined(nimDumpRpcs):
|
||||
echo "\n", pathStr, ": ", result.repr
|
||||
|
||||
# TODO: Allow cross checking between client signatures and server calls
|
||||
@ -1,3 +1,3 @@
|
||||
import eth-rpc / client
|
||||
import rpc / client
|
||||
export client
|
||||
|
||||
|
||||
@ -1,2 +1,2 @@
|
||||
import eth-rpc / server
|
||||
import rpc / server
|
||||
export server
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user