version 0.7.3

.github/workflows/ci.yml

@@ -1,53 +1,31 @@
 name: CI
 
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-  workflow_dispatch:
+on: [push, pull_request]
 
 jobs:
   test:
     runs-on: ubuntu-latest
-    timeout-minutes: 30
     strategy:
       matrix:
-        nim: [2.0.14, 2.2.2]
+        nim: [1.6.16, stable]
     steps:
     - name: Checkout
-      uses: actions/checkout@v4
-      with:
-        ref: ${{ github.event.pull_request.head.sha }}
-
+      uses: actions/checkout@v2
     - name: Install Nim
-      uses: iffy/install-nim@v4
+      uses: iffy/install-nim@v3
       with:
         version: ${{ matrix.nim }}
-
     - name: Install NodeJS
-      uses: actions/setup-node@v4
+      uses: actions/setup-node@v2
       with:
-        node-version: 18
-
+        node-version: '14'
     - name: Install test node
       working-directory: testnode
       run: npm install
-
     - name: Run test node
       working-directory: testnode
       run: npm start &
-
     - name: Build
-      run: nimble install -y --maximumtaggedversions=2
-
+      run: nimble install -y
     - name: Test
       run: nimble test -y
-
-  status:
-    if: always()
-    needs: [test]
-    runs-on: ubuntu-latest
-    steps:
-      - if: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled')  || contains(needs.*.result, 'skipped') }}
-        run: exit 1

.gitignore

@@ -4,6 +4,3 @@
 nimble.develop
 nimble.paths
 .idea
-.nimble
-.envrc
-nimbledeps

Readme.md

@@ -14,13 +14,7 @@ Use the [Nimble][2] package manager to add `ethers` to an existing
 project. Add the following to its .nimble file:
 
 ```nim
-requires "ethers >= 2.0.0 & < 3.0.0"
-```
-
-To avoid conflicts with previous versions of `contractabi`, use the following command to install dependencies:
-
-```bash
-nimble install --maximumtaggedversions=2
+requires "ethers >= 0.7.3 & < 0.8.0"
 ```
 
 Usage
@@ -137,22 +131,14 @@ You can now subscribe to Transfer events by calling `subscribe` on the contract
 instance.
 
 ```nim
-proc handleTransfer(transferResult: ?!Transfer) =
-  if transferResult.isOk:
-    echo "received transfer: ", transferResult.value
-  else:
-    echo "error during transfer: ", transferResult.error.msg
+proc handleTransfer(transfer: Transfer) =
+  echo "received transfer: ", transfer
 
 let subscription = await token.subscribe(Transfer, handleTransfer)
 ```
 
 When a Transfer event is emitted, the `handleTransfer` proc that you just
-defined will be called with a [Result](https://github.com/arnetheduck/nim-results) type
-which contains the event value.
-
-In case there is some underlying error in the event subscription, the handler will
-be called as well, but the Result will contain error instead, so do proper error
-management in your handlers.
+defined will be called.
 
 When you're no longer interested in these events, you can unsubscribe:
 
@@ -160,43 +146,6 @@ When you're no longer interested in these events, you can unsubscribe:
 await subscription.unsubscribe()
 ```
 
-Custom errors
--------------
-
-Solidity's [custom errors][4] are supported. To use them, you declare their type
-and indicate in which contract functions they can occur. For instance, this is
-how you would define the "InsufficientBalance" error to match the definition in
-[this Solidity example][5]:
-
-```nim
-type
-  InsufficientBalance = object of SolidityError
-    arguments: tuple[available: UInt256, required: UInt256]
-```
-
-Notice that `InsufficientBalance` inherits from `SoldityError`, and that it has
-an `arguments` tuple whose fields match the definition in Solidity.
-
-You can use the `{.errors.}` pragma to declare that this error may occur in a
-contract function:
-
-```nim
-proc transfer*(token: Erc20Token, recipient: Address, amount: UInt256)
-  {.contract, errors:[InsufficientBalance].}
-```
-
-This allows you to write error handling code for the `transfer` function like
-this:
-
-```nim
-try:
-  await token.transfer(recipient, 100.u256)
-except InsufficientBalance as error:
-  echo "insufficient balance"
-  echo "available balance: ", error.arguments.available
-  echo "required balance: ", error.arguments.required
-```
-
 Utilities
 ---------
 
@@ -204,13 +153,6 @@ This library ships with some optional modules that provides convenience utilitie
 
 - `ethers/erc20` module provides you with ERC20 token implementation and its events
 
-Hardhat websockets workaround
----------
-
-If you're working with Hardhat, you might encounter an issue where [websocket subscriptions stop working after 5 minutes](https://github.com/NomicFoundation/hardhat/issues/2053).
-
-This library provides a workaround using the compile time `ws_resubscribe` symbol. When this symbol is defined and set to a value greater than 0, websocket subscriptions will automatically resubscribe after the amount of time (in seconds) specified. The recommended value is 240 seconds (4 minutes), eg `--define:ws_resubscribe=240`.
-
 Contribution
 ------------
 
@@ -223,9 +165,6 @@ $ npm ci
 $ npm start
 ```
 
-If you need to use different port for the RPC node, then you can start with `npm start -- --port 1111` and
-then run the tests with `ETHERS_TEST_PROVIDER=1111 nimble test`.
-
 Thanks
 ------
 
@@ -236,5 +175,3 @@ affiliation) and [nim-web3][1] developers.
 [1]: https://github.com/status-im/nim-web3
 [2]: https://github.com/nim-lang/nimble
 [3]: https://docs.soliditylang.org/en/v0.8.11/contracts.html#state-mutability
-[4]: https://docs.soliditylang.org/en/v0.8.25/contracts.html#errors-and-the-revert-statement
-[5]: https://soliditylang.org/blog/2021/04/21/custom-errors/

config.nims

@@ -5,6 +5,3 @@
 when fileExists("nimble.paths"):
   include "nimble.paths"
 # end Nimble config
-
-when (NimMajor, NimMinor) >= (2, 0):
-  --mm:refc

ethers.nim

@@ -1,11 +1,11 @@
 import ./ethers/provider
 import ./ethers/signer
 import ./ethers/providers/jsonrpc
-import ./ethers/contracts
+import ./ethers/contract
 import ./ethers/wallet
 
 export provider
 export signer
 export jsonrpc
-export contracts
-export wallet
+export contract
+export wallet

ethers.nimble

@@ -1,20 +1,19 @@
-version = "2.1.0"
+version = "0.7.3"
 author = "Nim Ethers Authors"
 description = "library for interacting with Ethereum"
 license = "MIT"
 
-requires "nim >= 2.0.14"
-requires "chronicles >= 0.10.3 & < 0.13.0"
-requires "chronos >= 4.0.4 & < 4.1.0"
-requires "contractabi >= 0.7.2 & < 0.8.0"
+requires "nim >= 1.6.0"
+requires "chronicles >= 0.10.3 & < 0.11.0"
+requires "chronos >= 3.0.0 & < 4.0.0"
+requires "contractabi >= 0.6.0 & < 0.7.0"
 requires "questionable >= 0.10.2 & < 0.11.0"
-requires "json_rpc >= 0.5.0 & < 0.6.0"
-requires "serde >= 1.2.1 & < 1.3.0"
-requires "stint >= 0.8.1 & < 0.9.0"
-requires "stew >= 0.2.0"
-requires "eth >= 0.6.0 & < 0.10.0"
+requires "json_rpc"
+requires "stint"
+requires "stew"
+requires "eth"
 
 task test, "Run the test suite":
-  # exec "nimble install -d -y"
+  exec "nimble install -d -y"
   withDir "testmodule":
     exec "nimble test"

ethers/blocktag.nim

@@ -1,5 +1,4 @@
 import pkg/stint
-import pkg/questionable
 
 {.push raises:[].}
 
@@ -35,17 +34,3 @@ func `$`*(blockTag: BlockTag): string =
     blockTag.stringValue
   of numberBlockTag:
     "0x" & blockTag.numberValue.toHex
-
-func `==`*(a, b: BlockTag): bool =
-  case a.kind
-    of stringBlockTag:
-      a.stringValue == b.stringValue
-    of numberBlockTag:
-      a.numberValue == b.numberValue
-
-func number*(blockTag: BlockTag): ?UInt256 =
-  case blockTag.kind
-  of stringBlockTag:
-    UInt256.none
-  of numberBlockTag:
-    blockTag.numberValue.some

ethers/contract.nim

@@ -0,0 +1,310 @@
+import std/json
+import std/macros
+import std/sequtils
+import pkg/chronicles
+import pkg/chronos
+import pkg/contractabi
+import ./basics
+import ./provider
+import ./signer
+import ./events
+import ./fields
+
+export basics
+export provider
+export events
+
+logScope:
+  topics = "ethers contract"
+
+type
+  Contract* = ref object of RootObj
+    provider: Provider
+    signer: ?Signer
+    address: Address
+  TransactionOverrides* = ref object of RootObj
+    nonce*: ?UInt256
+    chainId*: ?UInt256
+    gasPrice*: ?UInt256
+    maxFee*: ?UInt256
+    maxPriorityFee*: ?UInt256
+    gasLimit*: ?UInt256
+  CallOverrides* = ref object of TransactionOverrides
+    blockTag*: ?BlockTag
+
+  ContractError* = object of EthersError
+  Confirmable* = ?TransactionResponse
+  EventHandler*[E: Event] = proc(event: E) {.gcsafe, raises:[].}
+
+func new*(ContractType: type Contract,
+          address: Address,
+          provider: Provider): ContractType =
+  ContractType(provider: provider, address: address)
+
+func new*(ContractType: type Contract,
+          address: Address,
+          signer: Signer): ContractType =
+  ContractType(signer: some signer, provider: signer.provider, address: address)
+
+func connect*[T: Contract](contract: T, provider: Provider | Signer): T =
+  T.new(contract.address, provider)
+
+func provider*(contract: Contract): Provider =
+  contract.provider
+
+func signer*(contract: Contract): ?Signer =
+  contract.signer
+
+func address*(contract: Contract): Address =
+  contract.address
+
+template raiseContractError(message: string) =
+  raise newException(ContractError, message)
+
+proc createTransaction(contract: Contract,
+                       function: string,
+                       parameters: tuple,
+                       overrides = TransactionOverrides()): Transaction =
+  let selector = selector(function, typeof parameters).toArray
+  let data = @selector & AbiEncoder.encode(parameters)
+  Transaction(
+    to: contract.address,
+    data: data,
+    nonce: overrides.nonce,
+    chainId: overrides.chainId,
+    gasPrice: overrides.gasPrice,
+    maxFee: overrides.maxFee,
+    maxPriorityFee: overrides.maxPriorityFee,
+    gasLimit: overrides.gasLimit,
+  )
+
+proc decodeResponse(T: type, multiple: static bool, bytes: seq[byte]): T =
+  when multiple:
+    without decoded =? AbiDecoder.decode(bytes, T):
+      raiseContractError "unable to decode return value as " & $T
+    return decoded
+  else:
+    return decodeResponse((T,), true, bytes)[0]
+
+proc call(provider: Provider,
+          transaction: Transaction,
+          overrides: TransactionOverrides): Future[seq[byte]] =
+  if overrides of CallOverrides and
+     blockTag =? CallOverrides(overrides).blockTag:
+    provider.call(transaction, blockTag)
+  else:
+    provider.call(transaction)
+
+proc call(contract: Contract,
+          function: string,
+          parameters: tuple,
+          overrides = TransactionOverrides()) {.async.} =
+  var transaction = createTransaction(contract, function, parameters, overrides)
+
+  if signer =? contract.signer and transaction.sender.isNone:
+    transaction.sender = some(await signer.getAddress())
+
+  discard await contract.provider.call(transaction, overrides)
+
+proc call(contract: Contract,
+          function: string,
+          parameters: tuple,
+          ReturnType: type,
+          returnMultiple: static bool,
+          overrides = TransactionOverrides()): Future[ReturnType] {.async.} =
+  var transaction = createTransaction(contract, function, parameters, overrides)
+
+  if signer =? contract.signer and transaction.sender.isNone:
+    transaction.sender = some(await signer.getAddress())
+
+  let response = await contract.provider.call(transaction, overrides)
+  return decodeResponse(ReturnType, returnMultiple, response)
+
+proc send(contract: Contract,
+          function: string,
+          parameters: tuple,
+          overrides = TransactionOverrides()):
+         Future[?TransactionResponse] {.async.} =
+  if signer =? contract.signer:
+    let transaction = createTransaction(contract, function, parameters, overrides)
+    let populated = await signer.populateTransaction(transaction)
+    let txResp = await signer.sendTransaction(populated)
+    return txResp.some
+  else:
+    await call(contract, function, parameters)
+    return TransactionResponse.none
+
+func getParameterTuple(procedure: NimNode): NimNode =
+  let parameters = procedure[3]
+  var tupl = newNimNode(nnkTupleConstr, parameters)
+  for parameter in parameters[2..^1]:
+    for name in parameter[0..^3]:
+      tupl.add name
+  return tupl
+
+func isConstant(procedure: NimNode): bool =
+  let pragmas = procedure[4]
+  for pragma in pragmas:
+    if pragma.eqIdent "view":
+      return true
+    elif pragma.eqIdent "pure":
+      return true
+  false
+
+func isMultipleReturn(returnType: NimNode): bool =
+  (returnType.kind == nnkPar and returnType.len > 1) or
+  (returnType.kind == nnkTupleConstr) or
+  (returnType.kind == nnkTupleTy)
+
+func addOverrides(procedure: var NimNode) =
+  procedure[3].add(
+    newIdentDefs(
+      ident("overrides"),
+      newEmptyNode(),
+      quote do: TransactionOverrides()
+    )
+  )
+
+func addContractCall(procedure: var NimNode) =
+  let contract = procedure[3][1][0]
+  let function = $basename(procedure[0])
+  let parameters = getParameterTuple(procedure)
+  let returnType = procedure[3][0]
+  let returnMultiple = returnType.isMultipleReturn.newLit
+
+  procedure.addOverrides()
+
+  func call: NimNode =
+    if returnType.kind == nnkEmpty:
+      quote:
+        await call(`contract`, `function`, `parameters`, overrides)
+    else:
+      quote:
+        return await call(
+          `contract`, `function`, `parameters`, `returnType`, `returnMultiple`, overrides)
+
+  func send: NimNode =
+    if returnType.kind == nnkEmpty:
+      quote:
+        discard await send(`contract`, `function`, `parameters`, overrides)
+    else:
+      quote:
+        when typeof(result) isnot Confirmable:
+          {.error: "unexpected return type, missing {.view.} or {.pure.} ?".}
+        return await send(`contract`, `function`, `parameters`, overrides)
+
+  procedure[6] =
+    if procedure.isConstant:
+      call()
+    else:
+      send()
+
+func addFuture(procedure: var NimNode) =
+  let returntype = procedure[3][0]
+  if returntype.kind != nnkEmpty:
+    procedure[3][0] = quote: Future[`returntype`]
+
+func addAsyncPragma(procedure: var NimNode) =
+  let pragmas = procedure[4]
+  if pragmas.kind == nnkEmpty:
+    procedure[4] = newNimNode(nnkPragma)
+  procedure[4].add ident("async")
+
+macro contract*(procedure: untyped{nkProcDef|nkMethodDef}): untyped =
+
+  let parameters = procedure[3]
+  let body = procedure[6]
+
+  parameters.expectMinLen(2) # at least return type and contract instance
+  body.expectKind(nnkEmpty)
+
+  var contractcall = copyNimTree(procedure)
+  contractcall.addContractCall()
+  contractcall.addFuture()
+  contractcall.addAsyncPragma()
+  contractcall
+
+template view* {.pragma.}
+template pure* {.pragma.}
+
+proc subscribe*[E: Event](contract: Contract,
+                          _: type E,
+                          handler: EventHandler[E]):
+                         Future[Subscription] =
+
+  let topic = topic($E, E.fieldTypes).toArray
+  let filter = EventFilter(address: contract.address, topics: @[topic])
+
+  proc logHandler(log: Log) {.raises: [].} =
+    if event =? E.decode(log.data, log.topics):
+      handler(event)
+
+  contract.provider.subscribe(filter, logHandler)
+
+proc confirm*(tx: Future[?TransactionResponse],
+              confirmations: int = EthersDefaultConfirmations,
+              timeout: int = EthersReceiptTimeoutBlks):
+             Future[TransactionReceipt] {.async.} =
+  ## Convenience method that allows confirm to be chained to a contract
+  ## transaction, eg:
+  ## `await token.connect(signer0)
+  ##          .mint(accounts[1], 100.u256)
+  ##          .confirm(3)`
+  without response =? (await tx):
+    raise newException(
+      EthersError,
+      "Transaction hash required. Possibly was a call instead of a send?"
+    )
+
+  return await response.confirm(confirmations, timeout)
+
+proc queryFilter[E: Event](contract: Contract,
+                            _: type E,
+                            filter: EventFilter):
+                           Future[seq[E]] {.async.} =
+
+  var logs = await contract.provider.getLogs(filter)
+  logs.keepItIf(not it.removed)
+
+  var events: seq[E] = @[]
+  for log in logs:
+    if event =? E.decode(log.data, log.topics):
+      events.add event
+
+  return events
+
+proc queryFilter*[E: Event](contract: Contract,
+                            _: type E):
+                           Future[seq[E]] =
+
+  let topic = topic($E, E.fieldTypes).toArray
+  let filter = EventFilter(address: contract.address,
+                           topics: @[topic])
+
+  contract.queryFilter(E, filter)
+
+proc queryFilter*[E: Event](contract: Contract,
+                            _: type E,
+                            blockHash: BlockHash):
+                           Future[seq[E]] =
+
+  let topic = topic($E, E.fieldTypes).toArray
+  let filter = FilterByBlockHash(address: contract.address,
+                                 topics: @[topic],
+                                 blockHash: blockHash)
+
+  contract.queryFilter(E, filter)
+
+proc queryFilter*[E: Event](contract: Contract,
+                            _: type E,
+                            fromBlock: BlockTag,
+                            toBlock: BlockTag):
+                           Future[seq[E]] =
+
+  let topic = topic($E, E.fieldTypes).toArray
+  let filter = Filter(address: contract.address,
+                      topics: @[topic],
+                      fromBlock: fromBlock,
+                      toBlock: toBlock)
+
+  contract.queryFilter(E, filter)

ethers/contracts.nim

@@ -1,31 +0,0 @@
-import std/macros
-import ./contracts/contract
-import ./contracts/overrides
-import ./contracts/confirmation
-import ./contracts/events
-import ./contracts/filters
-import ./contracts/syntax
-import ./contracts/gas
-import ./contracts/function
-
-export contract
-export overrides
-export confirmation
-export events
-export filters
-export syntax.view
-export syntax.pure
-export syntax.getter
-export syntax.errors
-export gas.estimateGas
-
-{.push raises: [].}
-
-macro contract*(procedure: untyped{nkProcDef | nkMethodDef}): untyped =
-  procedure.params.expectMinLen(2) # at least return type and contract instance
-  procedure.body.expectKind(nnkEmpty)
-
-  newStmtList(
-    createContractFunction(procedure),
-    createGasEstimationCall(procedure)
-  )

ethers/contracts/confirmation.nim

@@ -1,45 +0,0 @@
-import ../provider
-import ./errors/conversion
-
-{.push raises: [].}
-
-type Confirmable* = object
-  response*: ?TransactionResponse
-  convert*: ConvertCustomErrors
-
-proc confirm(tx: Confirmable, confirmations, timeout: int):
-  Future[TransactionReceipt] {.async: (raises: [CancelledError, EthersError]).} =
-
-  without response =? tx.response:
-    raise newException(
-      EthersError,
-      "Transaction hash required. Possibly was a call instead of a send?"
-    )
-
-  try:
-    return await response.confirm(confirmations, timeout)
-  except ProviderError as error:
-    let convert = tx.convert
-    raise convert(error)
-
-proc confirm*(tx: Future[Confirmable],
-              confirmations: int = EthersDefaultConfirmations,
-              timeout: int = EthersReceiptTimeoutBlks):
-             Future[TransactionReceipt] {.async: (raises: [CancelledError, EthersError]).} =
-  ## Convenience method that allows confirm to be chained to a contract
-  ## transaction, eg:
-  ## `await token.connect(signer0)
-  ##          .mint(accounts[1], 100.u256)
-  ##          .confirm(3)`
-  try:
-    return await (await tx).confirm(confirmations, timeout)
-  except CancelledError as e:
-    raise e
-  except EthersError as e:
-    raise e
-  except CatchableError as e:
-    raise newException(
-      EthersError,
-      "Error when trying to confirm the contract transaction: " & e.msg
-    )
-

ethers/contracts/contract.nim

@@ -1,36 +0,0 @@
-import ../basics
-import ../provider
-import ../signer
-
-{.push raises:[].}
-
-type Contract* = ref object of RootObj
-  provider: Provider
-  signer: ?Signer
-  address: Address
-
-func new*(ContractType: type Contract,
-          address: Address,
-          provider: Provider): ContractType =
-  ContractType(provider: provider, address: address)
-
-func new*(ContractType: type Contract,
-          address: Address,
-          signer: Signer): ContractType {.raises: [SignerError].} =
-  ContractType(signer: some signer, provider: signer.provider, address: address)
-
-func connect*[C: Contract](contract: C, provider: Provider): C =
-  C.new(contract.address, provider)
-
-func connect*[C: Contract](contract: C, signer: Signer): C {.raises: [SignerError].} =
-  C.new(contract.address, signer)
-
-func provider*(contract: Contract): Provider =
-  contract.provider
-
-func signer*(contract: Contract): ?Signer =
-  contract.signer
-
-func address*(contract: Contract): Address =
-  contract.address
-

ethers/contracts/contractcall.nim

@@ -1,35 +0,0 @@
-import ../basics
-import ./contract
-import ./overrides
-
-type ContractCall*[Arguments: tuple] = object
-  contract: Contract
-  function: string
-  arguments: Arguments
-  overrides: TransactionOverrides
-
-func init*[Arguments: tuple](
-  _: type ContractCall,
-  contract: Contract,
-  function: string,
-  arguments: Arguments,
-  overrides: TransactionOverrides
-): ContractCall[arguments] =
-  ContractCall[Arguments](
-    contract: contract,
-    function: function,
-    arguments: arguments,
-    overrides: overrides
-  )
-
-func contract*(call: ContractCall): Contract =
-  call.contract
-
-func function*(call: ContractCall): string =
-  call.function
-
-func arguments*(call: ContractCall): auto =
-  call.arguments
-
-func overrides*(call: ContractCall): TransactionOverrides =
-  call.overrides

ethers/contracts/errors.nim

@@ -1,29 +0,0 @@
-import std/macros
-import ./errors/conversion
-
-func getErrorTypes*(procedure: NimNode): NimNode =
-  let pragmas = procedure[4]
-  var tupl = newNimNode(nnkTupleConstr)
-  for pragma in pragmas:
-    if pragma.kind == nnkExprColonExpr:
-      if pragma[0].eqIdent "errors":
-        pragma[1].expectKind(nnkBracket)
-        for error in pragma[1]:
-          tupl.add error
-  if tupl.len == 0:
-    quote do: tuple[]
-  else:
-    tupl
-
-func addErrorHandling*(procedure: var NimNode) =
-  let body = procedure[6]
-  let errors = getErrorTypes(procedure)
-  procedure.body = quote do:
-    try:
-      `body`
-    except ProviderError as error:
-      if data =? error.data:
-        let convert = customErrorConversion(`errors`)
-        raise convert(error)
-      else:
-        raise error

ethers/contracts/errors/conversion.nim

@@ -1,15 +0,0 @@
-import ../../basics
-import ../../provider
-import ./encoding
-
-type ConvertCustomErrors* =
-    proc(error: ref ProviderError): ref EthersError {.gcsafe, raises:[].}
-
-func customErrorConversion*(ErrorTypes: type tuple): ConvertCustomErrors =
-  func convert(error: ref ProviderError): ref EthersError =
-    if data =? error.data:
-      for e in ErrorTypes.default.fields:
-        if error =? typeof(e).decode(data):
-          return error
-    return error
-  convert

ethers/contracts/errors/encoding.nim

@@ -1,37 +0,0 @@
-import pkg/contractabi
-import pkg/contractabi/selector
-import ../../basics
-import ../../errors
-
-func selector(E: type): FunctionSelector =
-  when compiles(E.arguments):
-    selector($E, typeof(E.arguments))
-  else:
-    selector($E, tuple[])
-
-func matchesSelector(E: type, data: seq[byte]): bool =
-  const selector = E.selector.toArray
-  data.len >= 4 and selector[0..<4] == data[0..<4]
-
-func decodeArguments(E: type, data: seq[byte]): auto =
-  AbiDecoder.decode(data[4..^1], E.arguments)
-
-func decode*[E: SolidityError](_: type E, data: seq[byte]): ?!(ref E) =
-  if not E.matchesSelector(data):
-    return failure "unable to decode " & $E & ": selector doesn't match"
-  when compiles(E.arguments):
-    without arguments =? E.decodeArguments(data), error:
-      return failure "unable to decode arguments of " & $E & ": " & error.msg
-    let message = "EVM reverted: " & $E & $arguments
-    success (ref E)(msg: message, arguments: arguments)
-  else:
-    if data.len > 4:
-      return failure "unable to decode: " & $E & ".arguments is not defined"
-    let message = "EVM reverted: " & $E & "()"
-    success (ref E)(msg: message)
-
-func encode*[E: SolidityError](_: type AbiEncoder, error: ref E): seq[byte] =
-  result = @(E.selector.toArray)
-  when compiles(error.arguments):
-    result &= AbiEncoder.encode(error.arguments)
-

ethers/contracts/filters.nim

@@ -1,78 +0,0 @@
-import std/sequtils
-import pkg/contractabi
-import ../basics
-import ../provider
-import ./contract
-import ./events
-import ./fields
-
-type EventHandler*[E: Event] = proc(event: ?!E) {.gcsafe, raises:[].}
-
-proc subscribe*[E: Event](contract: Contract,
-                          _: type E,
-                          handler: EventHandler[E]):
-                         Future[Subscription] =
-
-  let topic = topic($E, E.fieldTypes).toArray
-  let filter = EventFilter(address: contract.address, topics: @[topic])
-
-  proc logHandler(logResult: ?!Log) {.raises: [].} =
-    without log =? logResult, error:
-      handler(failure(E, error))
-      return
-
-    if event =? E.decode(log.data, log.topics):
-      handler(success(event))
-
-  contract.provider.subscribe(filter, logHandler)
-
-proc queryFilter[E: Event](contract: Contract,
-                            _: type E,
-                            filter: EventFilter):
-                           Future[seq[E]] {.async.} =
-
-  var logs = await contract.provider.getLogs(filter)
-  logs.keepItIf(not it.removed)
-
-  var events: seq[E] = @[]
-  for log in logs:
-    if event =? E.decode(log.data, log.topics):
-      events.add event
-
-  return events
-
-proc queryFilter*[E: Event](contract: Contract,
-                            _: type E):
-                           Future[seq[E]] =
-
-  let topic = topic($E, E.fieldTypes).toArray
-  let filter = EventFilter(address: contract.address,
-                           topics: @[topic])
-
-  contract.queryFilter(E, filter)
-
-proc queryFilter*[E: Event](contract: Contract,
-                            _: type E,
-                            blockHash: BlockHash):
-                           Future[seq[E]] =
-
-  let topic = topic($E, E.fieldTypes).toArray
-  let filter = FilterByBlockHash(address: contract.address,
-                                 topics: @[topic],
-                                 blockHash: blockHash)
-
-  contract.queryFilter(E, filter)
-
-proc queryFilter*[E: Event](contract: Contract,
-                            _: type E,
-                            fromBlock: BlockTag,
-                            toBlock: BlockTag):
-                           Future[seq[E]] =
-
-  let topic = topic($E, E.fieldTypes).toArray
-  let filter = Filter(address: contract.address,
-                      topics: @[topic],
-                      fromBlock: fromBlock,
-                      toBlock: toBlock)
-
-  contract.queryFilter(E, filter)

ethers/contracts/function.nim

@@ -1,60 +0,0 @@
-import std/macros
-import ./errors/conversion
-import ./syntax
-import ./transactions
-import ./errors
-
-func addContractCall(procedure: var NimNode) =
-  let contractCall = getContractCall(procedure)
-  let returnType = procedure.params[0]
-  let isGetter = procedure.isGetter
-
-  let errors = getErrorTypes(procedure)
-
-  func call: NimNode =
-    if returnType.kind == nnkEmpty:
-      quote:
-        await callTransaction(`contractCall`)
-    elif returnType.isMultipleReturn or isGetter:
-      quote:
-        return await callTransaction(`contractCall`, `returnType`)
-    else:
-      quote:
-        # solidity functions return a tuple, so wrap return type in a tuple
-        let tupl = await callTransaction(`contractCall`, (`returnType`,))
-        return tupl[0]
-
-  func send: NimNode =
-    if returnType.kind == nnkEmpty:
-      quote:
-        discard await sendTransaction(`contractCall`)
-    else:
-      quote:
-        when typeof(result) isnot Confirmable:
-          {.error:
-            "unexpected return type, " &
-            "missing {.view.}, {.pure.} or {.getter.} ?"
-          .}
-        let response = await sendTransaction(`contractCall`)
-        let convert = customErrorConversion(`errors`)
-        Confirmable(response: response, convert: convert)
-
-  procedure.body =
-    if procedure.isConstant:
-      call()
-    else:
-      send()
-
-func addFuture(procedure: var NimNode) =
-  let returntype = procedure[3][0]
-  if returntype.kind != nnkEmpty:
-    procedure[3][0] = quote: Future[`returntype`]
-
-func createContractFunction*(procedure: NimNode): NimNode =
-  result = copyNimTree(procedure)
-  result.addOverridesParameter()
-  result.addContractCall()
-  result.addErrorHandling()
-  result.addFuture()
-  result.addAsyncPragma()
-

ethers/contracts/gas.nim

@@ -1,51 +0,0 @@
-import std/macros
-import ../basics
-import ../provider
-import ../signer
-import ./contract
-import ./contractcall
-import ./transactions
-import ./overrides
-import ./errors
-import ./syntax
-
-type ContractGasEstimations[C] = distinct C
-
-func estimateGas*[C: Contract](contract: C): ContractGasEstimations[C] =
-  ContractGasEstimations[C](contract)
-
-proc estimateGas(
-  call: ContractCall
-): Future[UInt256] {.async: (raises: [CancelledError, ProviderError, EthersError]).} =
-  let transaction = createTransaction(call)
-  var blockTag = BlockTag.pending
-  if call.overrides of CallOverrides:
-    if tag =? CallOverrides(call.overrides).blockTag:
-      blockTag = tag
-  if signer =? call.contract.signer:
-    await signer.estimateGas(transaction, blockTag)
-  else:
-    await call.contract.provider.estimateGas(transaction, blockTag)
-
-func wrapFirstParameter(procedure: var NimNode) =
-  let contractType = procedure.params[1][1]
-  let gasEstimationsType = quote do: ContractGasEstimations[`contractType`]
-  procedure.params[1][1] = gasEstimationsType
-
-func setReturnType(procedure: var NimNode) =
-  procedure.params[0] = quote do: Future[UInt256]
-
-func addEstimateCall(procedure: var NimNode) =
-  let contractCall = getContractCall(procedure)
-  procedure.body = quote do:
-    return await estimateGas(`contractCall`)
-
-func createGasEstimationCall*(procedure: NimNode): NimNode =
-  result = copyNimTree(procedure)
-  result.wrapFirstParameter()
-  result.addOverridesParameter()
-  result.setReturnType()
-  result.addAsyncPragma()
-  result.addUsedPragma()
-  result.addEstimateCall()
-  result.addErrorHandling()

ethers/contracts/overrides.nim

@@ -1,13 +0,0 @@
-import ../basics
-import ../blocktag
-
-type
-  TransactionOverrides* = ref object of RootObj
-    nonce*: ?UInt256
-    chainId*: ?UInt256
-    gasPrice*: ?UInt256
-    maxFeePerGas*: ?UInt256
-    maxPriorityFeePerGas*: ?UInt256
-    gasLimit*: ?UInt256
-  CallOverrides* = ref object of TransactionOverrides
-    blockTag*: ?BlockTag

ethers/contracts/syntax.nim

@@ -1,76 +0,0 @@
-import std/macros
-import ./contractcall
-
-template view* {.pragma.}
-template pure* {.pragma.}
-template getter* {.pragma.}
-template errors*(types) {.pragma.}
-
-func isGetter*(procedure: NimNode): bool =
-  let pragmas = procedure[4]
-  for pragma in pragmas:
-    if pragma.eqIdent "getter":
-      return true
-  false
-
-func isConstant*(procedure: NimNode): bool =
-  let pragmas = procedure[4]
-  for pragma in pragmas:
-    if pragma.eqIdent "view":
-      return true
-    elif pragma.eqIdent "pure":
-      return true
-    elif pragma.eqIdent "getter":
-      return true
-  false
-
-func isMultipleReturn*(returnType: NimNode): bool =
-  (returnType.kind == nnkPar and returnType.len > 1) or
-  (returnType.kind == nnkTupleConstr) or
-  (returnType.kind == nnkTupleTy)
-
-func getContract(procedure: NimNode): NimNode =
-  let firstArgument = procedure.params[1][0]
-  quote do:
-    Contract(`firstArgument`)
-
-func getFunctionName(procedure: NimNode): string =
-  $basename(procedure[0])
-
-func getArgumentTuple(procedure: NimNode): NimNode =
-  let parameters = procedure.params
-  var arguments = newNimNode(nnkTupleConstr, parameters)
-  for parameter in parameters[2..^2]:
-    for name in parameter[0..^3]:
-      arguments.add name
-  return arguments
-
-func getOverrides(procedure: NimNode): NimNode =
-  procedure.params.last[^3]
-
-func getContractCall*(procedure: NimNode): NimNode =
-  let contract = getContract(procedure)
-  let function = getFunctionName(procedure)
-  let arguments = getArgumentTuple(procedure)
-  let overrides = getOverrides(procedure)
-  quote do:
-    ContractCall.init(`contract`, `function`, `arguments`, `overrides`)
-
-func addOverridesParameter*(procedure: var NimNode) =
-  let overrides = genSym(nskParam, "overrides")
-  procedure.params.add(
-    newIdentDefs(
-      overrides,
-      newEmptyNode(),
-      quote do: TransactionOverrides()
-    )
-  )
-
-func addAsyncPragma*(procedure: var NimNode) =
-  procedure.addPragma nnkExprColonExpr.newTree(
-    quote do: async,
-    quote do: (raises: [CancelledError, ProviderError, EthersError])
-  )
-
-func addUsedPragma*(procedure: var NimNode) =
-  procedure.addPragma(quote do: used)

ethers/contracts/transactions.nim

@@ -1,71 +0,0 @@
-import pkg/contractabi
-import pkg/chronicles
-import ../basics
-import ../provider
-import ../signer
-import ../transaction
-import ./contract
-import ./contractcall
-import ./overrides
-
-{.push raises: [].}
-
-logScope:
-  topics = "ethers contract"
-
-proc createTransaction*(call: ContractCall): Transaction =
-  let selector = selector(call.function, typeof call.arguments).toArray
-  let data = @selector & AbiEncoder.encode(call.arguments)
-  Transaction(
-    to: call.contract.address,
-    data: data,
-    nonce: call.overrides.nonce,
-    chainId: call.overrides.chainId,
-    gasPrice: call.overrides.gasPrice,
-    maxFeePerGas: call.overrides.maxFeePerGas,
-    maxPriorityFeePerGas: call.overrides.maxPriorityFeePerGas,
-    gasLimit: call.overrides.gasLimit,
-  )
-
-proc decodeResponse(T: type, bytes: seq[byte]): T {.raises: [ContractError].} =
-  without decoded =? AbiDecoder.decode(bytes, T):
-    raise newException(ContractError, "unable to decode return value as " & $T)
-  return decoded
-
-proc call(
-    provider: Provider, transaction: Transaction, overrides: TransactionOverrides
-): Future[seq[byte]] {.async: (raises: [ProviderError, CancelledError]).} =
-  if overrides of CallOverrides and blockTag =? CallOverrides(overrides).blockTag:
-    await provider.call(transaction, blockTag)
-  else:
-    await provider.call(transaction)
-
-proc callTransaction*(call: ContractCall) {.async: (raises: [ProviderError, SignerError, CancelledError]).} =
-  var transaction = createTransaction(call)
-
-  if signer =? call.contract.signer and transaction.sender.isNone:
-    transaction.sender = some(await signer.getAddress())
-
-  discard await call.contract.provider.call(transaction, call.overrides)
-
-proc callTransaction*(call: ContractCall, ReturnType: type): Future[ReturnType] {.async: (raises: [ProviderError, SignerError, ContractError, CancelledError]).} =
-  var transaction = createTransaction(call)
-
-  if signer =? call.contract.signer and transaction.sender.isNone:
-    transaction.sender = some(await signer.getAddress())
-
-  let response = await call.contract.provider.call(transaction, call.overrides)
-  return decodeResponse(ReturnType, response)
-
-proc sendTransaction*(call: ContractCall): Future[?TransactionResponse] {.async: (raises: [SignerError, ProviderError, CancelledError]).} =
-  if signer =? call.contract.signer:
-    withLock(signer):
-      let transaction = createTransaction(call)
-      let populated = await signer.populateTransaction(transaction)
-      trace "sending contract transaction", function = call.function, params = $call.arguments
-      let txResp = await signer.sendTransaction(populated)
-      return txResp.some
-  else:
-    await callTransaction(call)
-    return TransactionResponse.none
-

ethers/erc20.nim

@@ -46,17 +46,17 @@ method allowance*(token: Erc20Token,
 
 method transfer*(token: Erc20Token,
                  recipient: Address,
-                 amount: UInt256): Confirmable {.base, contract.}
+                 amount: UInt256): ?TransactionResponse {.base, contract.}
   ## Moves `amount` tokens from the caller's account to `recipient`.
 
 method approve*(token: Erc20Token,
                 spender: Address,
-                amount: UInt256): Confirmable {.base, contract.}
+                amount: UInt256): ?TransactionResponse {.base, contract.}
   ## Sets `amount` as the allowance of `spender` over the caller's tokens.
 
 method increaseAllowance*(token: Erc20Token,
                 spender: Address,
-                addedValue: UInt256): Confirmable {.base, contract.}
+                addedValue: UInt256): ?TransactionResponse {.base, contract.}
   ## Atomically increases the allowance granted to spender by the caller.
   ## This is an alternative to approve that can be used as a mitigation for problems described in IERC20.approve.
   ## Emits an Approval event indicating the updated allowance.
@@ -65,7 +65,7 @@ method increaseAllowance*(token: Erc20Token,
 
 method decreaseAllowance*(token: Erc20Token,
                 spender: Address,
-                addedValue: UInt256): Confirmable {.base, contract.}
+                addedValue: UInt256): ?TransactionResponse {.base, contract.}
   ## Atomically decreases the allowance granted to spender by the caller.
   ## This is an alternative to approve that can be used as a mitigation for problems described in IERC20.approve.
   ## Emits an Approval event indicating the updated allowance.
@@ -75,6 +75,6 @@ method decreaseAllowance*(token: Erc20Token,
 method transferFrom*(token: Erc20Token,
                      spender: Address,
                      recipient: Address,
-                     amount: UInt256): Confirmable {.base, contract.}
-  ## Moves `amount` tokens from `spender` to `recipient` using the allowance
+                     amount: UInt256): ?TransactionResponse {.base, contract.}
+  ## Moves `amount` tokens from `from` to `to` using the allowance
   ## mechanism. `amount` is then deducted from the caller's allowance.

ethers/errors.nim

@@ -1,18 +0,0 @@
-import ./basics
-
-type
-  SolidityError* = object of EthersError
-  ContractError* = object of EthersError
-  SignerError* = object of EthersError
-  SubscriptionError* = object of EthersError
-  ProviderError* = object of EthersError
-    data*: ?seq[byte]
-
-{.push raises:[].}
-
-proc toErr*[E1: ref CatchableError, E2: EthersError](
-  e1: E1,
-  _: type E2,
-  msg: string = e1.msg): ref E2 =
-
-  return newException(E2, msg, e1)

ethers/events.nim

@@ -1,7 +1,7 @@
 import std/macros
 import pkg/contractabi
-import ../basics
-import ../provider
+import ./basics
+import ./provider
 
 type
   Event* = object of RootObj

ethers/nimshims/hashes.nim

@@ -1,49 +0,0 @@
-## Fixes an underlying Exception caused by missing forward declarations for
-## `std/json.JsonNode.hash`, eg when using `JsonNode` as a `Table` key. Adds
-## {.raises: [].} for proper exception tracking. Copied from the std/json module
-
-import pkg/serde
-import std/hashes
-
-{.push raises:[].}
-
-when (NimMajor) >= 2:
-  proc hash*[A](x: openArray[A]): Hash =
-    ## Efficient hashing of arrays and sequences.
-    ## There must be a `hash` proc defined for the element type `A`.
-    when A is byte:
-      result = murmurHash(x)
-    elif A is char:
-      when nimvm:
-        result = hashVmImplChar(x, 0, x.high)
-      else:
-        result = murmurHash(toOpenArrayByte(x, 0, x.high))
-    else:
-      for a in x:
-        result = result !& hash(a)
-      result = !$result
-
-func hash*(n: OrderedTable[string, JsonNode]): Hash
-
-func hash*(n: JsonNode): Hash =
-  ## Compute the hash for a JSON node
-  case n.kind
-  of JArray:
-    result = hash(n.elems)
-  of JObject:
-    result = hash(n.fields)
-  of JInt:
-    result = hash(n.num)
-  of JFloat:
-    result = hash(n.fnum)
-  of JBool:
-    result = hash(n.bval.int)
-  of JString:
-    result = hash(n.str)
-  of JNull:
-    result = Hash(0)
-
-func hash*(n: OrderedTable[string, JsonNode]): Hash =
-  for key, val in n:
-    result = result xor (hash(key) !& hash(val))
-  result = !$result

ethers/provider.nim

@@ -1,32 +1,28 @@
 import pkg/chronicles
-import pkg/serde
-import pkg/questionable
+import pkg/stew/byteutils
 import ./basics
 import ./transaction
 import ./blocktag
-import ./errors
 
 export basics
 export transaction
 export blocktag
-export errors
 
 {.push raises: [].}
 
 type
   Provider* = ref object of RootObj
-  EstimateGasError* = object of ProviderError
-    transaction*: Transaction
+  ProviderError* = object of EthersError
   Subscription* = ref object of RootObj
-  EventFilter* {.serialize.} = ref object of RootObj
+  EventFilter* = ref object of RootObj
     address*: Address
     topics*: seq[Topic]
-  Filter* {.serialize.} = ref object of EventFilter
+  Filter* = ref object of EventFilter
     fromBlock*: BlockTag
     toBlock*: BlockTag
-  FilterByBlockHash* {.serialize.} = ref object of EventFilter
+  FilterByBlockHash* = ref object of EventFilter
     blockHash*: BlockHash
-  Log* {.serialize.} = object
+  Log* = object
     blockNumber*: UInt256
     data*: seq[byte]
     logIndex*: UInt256
@@ -40,9 +36,9 @@ type
     Invalid = 2
   TransactionResponse* = object
     provider*: Provider
-    hash* {.serialize.}: TransactionHash
-  TransactionReceipt* {.serialize.} = object
-    sender* {.serialize("from"), deserialize("from").}: ?Address
+    hash*: TransactionHash
+  TransactionReceipt* = object
+    sender*: ?Address
     to*: ?Address
     contractAddress*: ?Address
     transactionIndex*: UInt256
@@ -55,19 +51,18 @@ type
     cumulativeGasUsed*: UInt256
     effectiveGasPrice*: ?UInt256
     status*: TransactionStatus
-    transactionType* {.serialize("type"), deserialize("type").}: TransactionType
-  LogHandler* = proc(log: ?!Log) {.gcsafe, raises:[].}
-  BlockHandler* = proc(blck: ?!Block) {.gcsafe, raises:[].}
+    transactionType*: TransactionType
+  LogHandler* = proc(log: Log) {.gcsafe, raises:[].}
+  BlockHandler* = proc(blck: Block) {.gcsafe, raises:[].}
   Topic* = array[32, byte]
-  Block* {.serialize.} = object
+  Block* = object
     number*: ?UInt256
     timestamp*: UInt256
     hash*: ?BlockHash
-    baseFeePerGas* : ?UInt256
-  PastTransaction* {.serialize.} = object
+  PastTransaction* = object
     blockHash*: BlockHash
     blockNumber*: UInt256
-    sender* {.serialize("from"), deserialize("from").}: Address
+    sender*: Address
     gas*: UInt256
     gasPrice*: UInt256
     hash*: TransactionHash
@@ -75,7 +70,7 @@ type
     nonce*: UInt256
     to*: Address
     transactionIndex*: UInt256
-    transactionType* {.serialize("type"), deserialize("type").}: ?TransactionType
+    transactionType*: ?TransactionType
     chainId*: ?UInt256
     value*: UInt256
     v*, r*, s*: UInt256
@@ -92,101 +87,80 @@ template raiseProviderError(msg: string) =
 func toTransaction*(past: PastTransaction): Transaction =
   Transaction(
     sender: some past.sender,
-    to: past.to,
-    data: past.input,
-    value: past.value,
-    nonce: some past.nonce,
-    chainId: past.chainId,
     gasPrice: some past.gasPrice,
+    data: past.input,
+    nonce: some past.nonce,
+    to: past.to,
+    transactionType: past.transactionType,
     gasLimit: some past.gas,
-    transactionType: past.transactionType
+    chainId: past.chainId
   )
 
-method getBlockNumber*(
-    provider: Provider
-): Future[UInt256] {.base, async: (raises: [ProviderError, CancelledError]).} =
+method getBlockNumber*(provider: Provider): Future[UInt256] {.base, gcsafe.} =
   doAssert false, "not implemented"
 
-method getBlock*(
-    provider: Provider, tag: BlockTag
-): Future[?Block] {.base, async: (raises: [ProviderError, CancelledError]).} =
+method getBlock*(provider: Provider, tag: BlockTag): Future[?Block] {.base, gcsafe.} =
   doAssert false, "not implemented"
 
-method call*(
-    provider: Provider, tx: Transaction, blockTag = BlockTag.latest
-): Future[seq[byte]] {.base, async: (raises: [ProviderError, CancelledError]).} =
+method call*(provider: Provider,
+             tx: Transaction,
+             blockTag = BlockTag.latest): Future[seq[byte]] {.base, gcsafe.} =
   doAssert false, "not implemented"
 
-method getGasPrice*(
-    provider: Provider
-): Future[UInt256] {.base, async: (raises: [ProviderError, CancelledError]).} =
+method getGasPrice*(provider: Provider): Future[UInt256] {.base, gcsafe.} =
   doAssert false, "not implemented"
 
-method getMaxPriorityFeePerGas*(
-    provider: Provider
-): Future[UInt256] {.base, async: (raises: [CancelledError]).} =
+method getTransactionCount*(provider: Provider,
+                            address: Address,
+                            blockTag = BlockTag.latest):
+                           Future[UInt256] {.base, gcsafe.} =
   doAssert false, "not implemented"
 
-method getTransactionCount*(
-    provider: Provider, address: Address, blockTag = BlockTag.latest
-): Future[UInt256] {.base, async: (raises: [ProviderError, CancelledError]).} =
+method getTransaction*(provider: Provider,
+                       txHash: TransactionHash):
+                      Future[?PastTransaction] {.base, gcsafe.} =
   doAssert false, "not implemented"
 
-method getTransaction*(
-    provider: Provider, txHash: TransactionHash
-): Future[?PastTransaction] {.base, async: (raises: [ProviderError, CancelledError]).} =
+method getTransactionReceipt*(provider: Provider,
+                            txHash: TransactionHash):
+                           Future[?TransactionReceipt] {.base, gcsafe.} =
   doAssert false, "not implemented"
 
-method getTransactionReceipt*(
-    provider: Provider, txHash: TransactionHash
-): Future[?TransactionReceipt] {.
-    base, async: (raises: [ProviderError, CancelledError])
-.} =
+method sendTransaction*(provider: Provider,
+                        rawTransaction: seq[byte]):
+                       Future[TransactionResponse] {.base, gcsafe.} =
   doAssert false, "not implemented"
 
-method sendTransaction*(
-    provider: Provider, rawTransaction: seq[byte]
-): Future[TransactionResponse] {.
-    base, async: (raises: [ProviderError, CancelledError])
-.} =
+method getLogs*(provider: Provider,
+                filter: EventFilter): Future[seq[Log]] {.base, gcsafe.} =
   doAssert false, "not implemented"
 
-method getLogs*(
-    provider: Provider, filter: EventFilter
-): Future[seq[Log]] {.base, async: (raises: [ProviderError, CancelledError]).} =
+method estimateGas*(provider: Provider,
+                    transaction: Transaction,
+                    blockTag = BlockTag.latest): Future[UInt256] {.base, gcsafe.} =
   doAssert false, "not implemented"
 
-method estimateGas*(
-    provider: Provider, transaction: Transaction, blockTag = BlockTag.latest
-): Future[UInt256] {.base, async: (raises: [ProviderError, CancelledError]).} =
+method getChainId*(provider: Provider): Future[UInt256] {.base, gcsafe.} =
   doAssert false, "not implemented"
 
-method getChainId*(
-    provider: Provider
-): Future[UInt256] {.base, async: (raises: [ProviderError, CancelledError]).} =
+method subscribe*(provider: Provider,
+                  filter: EventFilter,
+                  callback: LogHandler):
+                 Future[Subscription] {.base, gcsafe.} =
   doAssert false, "not implemented"
 
-method subscribe*(
-    provider: Provider, filter: EventFilter, callback: LogHandler
-): Future[Subscription] {.base, async: (raises: [ProviderError, CancelledError]).} =
+method subscribe*(provider: Provider,
+                  callback: BlockHandler):
+                 Future[Subscription] {.base, gcsafe.} =
   doAssert false, "not implemented"
 
-method subscribe*(
-    provider: Provider, callback: BlockHandler
-): Future[Subscription] {.base, async: (raises: [ProviderError, CancelledError]).} =
+method unsubscribe*(subscription: Subscription) {.base, async.} =
   doAssert false, "not implemented"
 
-method unsubscribe*(
-    subscription: Subscription
-) {.base, async: (raises: [ProviderError, CancelledError]).} =
+method isSyncing*(provider: Provider): Future[bool] {.base, async.} =
   doAssert false, "not implemented"
 
-method isSyncing*(provider: Provider): Future[bool] {.base, async: (raises: [ProviderError, CancelledError]).} =
-  doAssert false, "not implemented"
-
-proc replay*(
-    provider: Provider, tx: Transaction, blockNumber: UInt256
-) {.async: (raises: [ProviderError, CancelledError]).} =
+proc replay*(provider: Provider, tx: Transaction, blockNumber: UInt256) {.async.} =
   # Replay transaction at block. Useful for fetching revert reasons, which will
   # be present in the raised error message. The replayed block number should
   # include the state of the chain in the block previous to the block in which
@@ -197,71 +171,79 @@ proc replay*(
   trace "replaying transaction", gasLimit = tx.gasLimit, tx = $tx
   discard await provider.call(tx, BlockTag.init(blockNumber))
 
+method getRevertReason*(
+  provider: Provider,
+  hash: TransactionHash,
+  blockNumber: UInt256
+): Future[?string] {.base, async.} =
+
+  without pastTx =? await provider.getTransaction(hash):
+    return none string
+
+  try:
+    await provider.replay(pastTx.toTransaction, blockNumber)
+    return none string
+  except ProviderError as e:
+    # should contain the revert reason
+    return some e.msg
+
+method getRevertReason*(
+  provider: Provider,
+  receipt: TransactionReceipt
+): Future[?string] {.base, async.} =
+
+  if receipt.status != TransactionStatus.Failure:
+    return none string
+
+  without blockNumber =? receipt.blockNumber:
+    return none string
+
+  return await provider.getRevertReason(receipt.transactionHash, blockNumber - 1)
+
 proc ensureSuccess(
-    provider: Provider, receipt: TransactionReceipt
-) {.async: (raises: [ProviderError, CancelledError]).} =
+  provider: Provider,
+  receipt: TransactionReceipt
+) {.async, raises: [ProviderError].} =
   ## If the receipt.status is Failed, the tx is replayed to obtain a revert
   ## reason, after which a ProviderError with the revert reason is raised.
   ## If no revert reason was obtained
 
   # TODO: handle TransactionStatus.Invalid?
-  if receipt.status != TransactionStatus.Failure:
-    return
+  if receipt.status == TransactionStatus.Failure:
+    logScope:
+      transactionHash = receipt.transactionHash.to0xHex
 
-  without blockNumber =? receipt.blockNumber and
-          pastTx =? await provider.getTransaction(receipt.transactionHash):
-    raiseProviderError("Transaction reverted with unknown reason")
+    trace "transaction failed, replaying transaction to get revert reason"
 
-  try:
-    await provider.replay(pastTx.toTransaction, blockNumber)
-    raiseProviderError("Transaction reverted with unknown reason")
-  except ProviderError as error:
-    raise error
-
-proc confirm*(
-  tx: TransactionResponse,
-  confirmations = EthersDefaultConfirmations,
-  timeout = EthersReceiptTimeoutBlks): Future[TransactionReceipt]
-  {.async: (raises: [CancelledError, ProviderError, SubscriptionError, EthersError]).} =
+    if revertReason =? await provider.getRevertReason(receipt):
+      trace "transaction revert reason obtained", revertReason
+      raiseProviderError(revertReason)
+    else:
+      trace "transaction replay completed, no revert reason obtained"
+      raiseProviderError("Transaction reverted with unknown reason")
 
+proc confirm*(tx: TransactionResponse,
+              confirmations = EthersDefaultConfirmations,
+              timeout = EthersReceiptTimeoutBlks):
+             Future[TransactionReceipt]
+             {.async, raises: [ProviderError, EthersError].} =
   ## Waits for a transaction to be mined and for the specified number of blocks
-  ## to pass since it was mined (confirmations). The number of confirmations
-  ## includes the block in which the transaction was mined.
+  ## to pass since it was mined (confirmations).
   ## A timeout, in blocks, can be specified that will raise an error if too many
   ## blocks have passed without the tx having been mined.
 
-  assert confirmations > 0
-
   var blockNumber: UInt256
-
-  ## We need initialized succesfull Result, because the first iteration of the `while` loop
-  ## bellow is triggered "manually" by calling `await updateBlockNumber` and not by block
-  ## subscription. If left uninitialized then the Result is in error state and error is raised.
-  ## This result is not used for block value, but for block subscription errors.
-  var blockSubscriptionResult: ?!Block = success(Block(number: UInt256.none, timestamp: 0.u256, hash: BlockHash.none))
   let blockEvent = newAsyncEvent()
 
-  proc updateBlockNumber {.async: (raises: []).} =
-    try:
-      let number = await tx.provider.getBlockNumber()
-      if number > blockNumber:
-        blockNumber = number
-        blockEvent.fire()
-    except ProviderError, CancelledError:
-      # there's nothing we can do here
-      discard
+  proc onBlockNumber(number: UInt256) =
+    blockNumber = number
+    blockEvent.fire()
 
-  proc onBlock(blckResult: ?!Block) =
-    blockSubscriptionResult = blckResult
+  proc onBlock(blck: Block) =
+    if number =? blck.number:
+      onBlockNumber(number)
 
-    if blckResult.isErr:
-      blockEvent.fire()
-      return
-
-    # ignore block parameter; hardhat may call this with pending blocks
-    asyncSpawn updateBlockNumber()
-
-  await updateBlockNumber()
+  onBlockNumber(await tx.provider.getBlockNumber())
   let subscription = await tx.provider.subscribe(onBlock)
 
   let finish = blockNumber + timeout.u256
@@ -271,16 +253,6 @@ proc confirm*(
     await blockEvent.wait()
     blockEvent.clear()
 
-    if blockSubscriptionResult.isErr:
-      let error = blockSubscriptionResult.error()
-
-      if error of SubscriptionError:
-        raise (ref SubscriptionError)(error)
-      elif error of CancelledError:
-        raise (ref CancelledError)(error)
-      else:
-        raise error.toErr(ProviderError)
-
     if blockNumber >= finish:
       await subscription.unsubscribe()
       raise newException(EthersError, "tx not mined before timeout")
@@ -296,27 +268,16 @@ proc confirm*(
       await tx.provider.ensureSuccess(receipt)
       return receipt
 
-proc confirm*(
-  tx: Future[TransactionResponse],
-  confirmations: int = EthersDefaultConfirmations,
-  timeout: int = EthersReceiptTimeoutBlks): Future[TransactionReceipt] {.async: (raises: [CancelledError, EthersError]).} =
+proc confirm*(tx: Future[TransactionResponse],
+             confirmations: int = EthersDefaultConfirmations,
+             timeout: int = EthersReceiptTimeoutBlks):
+            Future[TransactionReceipt] {.async.} =
   ## Convenience method that allows wait to be chained to a sendTransaction
   ## call, eg:
   ## `await signer.sendTransaction(populated).confirm(3)`
-  try:
-    let txResp = await tx
-    return await txResp.confirm(confirmations, timeout)
-  except CancelledError as e:
-    raise e
-  except EthersError as e:
-    raise e
-  except CatchableError as e:
-    raise newException(
-      EthersError,
-      "Error when trying to confirm the provider transaction: " & e.msg
-    )
 
-method close*(
-    provider: Provider
-) {.base, async: (raises: [ProviderError, CancelledError]).} =
+  let txResp = await tx
+  return await txResp.confirm(confirmations, timeout)
+
+method close*(provider: Provider) {.async, base.} =
   discard

ethers/providers/jsonrpc.nim

@@ -1,23 +1,21 @@
+import std/json
 import std/tables
 import std/uri
 import pkg/chronicles
-import pkg/eth/common/eth_types except Block, Log, Address, Transaction
+import pkg/eth/common/eth_types_json_serialization
 import pkg/json_rpc/rpcclient
 import pkg/json_rpc/errors
-import pkg/serde
 import ../basics
 import ../provider
 import ../signer
 import ./jsonrpc/rpccalls
 import ./jsonrpc/conversions
 import ./jsonrpc/subscriptions
-import ./jsonrpc/errors
 
+export json
 export basics
 export provider
 export chronicles
-export errors.JsonRpcProviderError
-export subscriptions
 
 {.push raises: [].}
 
@@ -28,94 +26,82 @@ type
   JsonRpcProvider* = ref object of Provider
     client: Future[RpcClient]
     subscriptions: Future[JsonRpcSubscriptions]
-    maxPriorityFeePerGas: UInt256
-
+  JsonRpcSigner* = ref object of Signer
+    provider: JsonRpcProvider
+    address: ?Address
+  JsonRpcProviderError* = object of ProviderError
   JsonRpcSubscription* = ref object of Subscription
     subscriptions: JsonRpcSubscriptions
     id: JsonNode
 
-  # Signer
-  JsonRpcSigner* = ref object of Signer
-    provider: JsonRpcProvider
-    address: ?Address
-  JsonRpcSignerError* = object of SignerError
+proc raiseJsonRpcProviderError(message: string) {.raises: [JsonRpcProviderError].} =
+  var message = message
+  try:
+    message = parseJson(message){"message"}.getStr
+  except Exception:
+    discard
+  raise newException(JsonRpcProviderError, message)
+
+template convertError(body) =
+  try:
+    body
+  except JsonRpcError as error:
+    raiseJsonRpcProviderError(error.msg)
+  # Catch all ValueErrors for now, at least until JsonRpcError is actually
+  # raised. PR created: https://github.com/status-im/nim-json-rpc/pull/151
+  except ValueError as error:
+    raiseJsonRpcProviderError(error.msg)
 
 # Provider
 
 const defaultUrl = "http://localhost:8545"
 const defaultPollingInterval = 4.seconds
-const defaultMaxPriorityFeePerGas = 1_000_000_000.u256
 
 proc jsonHeaders: seq[(string, string)] =
   @[("Content-Type", "application/json")]
 
-proc new*(
-  _: type JsonRpcProvider,
-  url=defaultUrl,
-  pollingInterval=defaultPollingInterval,
-  maxPriorityFeePerGas=defaultMaxPriorityFeePerGas): JsonRpcProvider {.raises: [JsonRpcProviderError].} =
-
+proc new*(_: type JsonRpcProvider,
+          url=defaultUrl,
+          pollingInterval=defaultPollingInterval): JsonRpcProvider =
   var initialized: Future[void]
   var client: RpcClient
   var subscriptions: JsonRpcSubscriptions
 
-  proc initialize() {.async: (raises: [JsonRpcProviderError, CancelledError]).} =
-    convertError:
-      case parseUri(url).scheme
-      of "ws", "wss":
-        let websocket = newRpcWebSocketClient(getHeaders = jsonHeaders)
-        await websocket.connect(url)
-        client = websocket
-        subscriptions = JsonRpcSubscriptions.new(websocket)
-      else:
-        let http = newRpcHttpClient(getHeaders = jsonHeaders)
-        await http.connect(url)
-        client = http
-        subscriptions = JsonRpcSubscriptions.new(http,
-                                                pollingInterval = pollingInterval)
-      subscriptions.start()
+  proc initialize {.async.} =
+    case parseUri(url).scheme
+    of "ws", "wss":
+      let websocket = newRpcWebSocketClient(getHeaders = jsonHeaders)
+      await websocket.connect(url)
+      client = websocket
+      subscriptions = JsonRpcSubscriptions.new(websocket)
+    else:
+      let http = newRpcHttpClient(getHeaders = jsonHeaders)
+      await http.connect(url)
+      client = http
+      subscriptions = JsonRpcSubscriptions.new(http,
+                                               pollingInterval = pollingInterval)
 
-  proc awaitClient(): Future[RpcClient] {.
-      async: (raises: [JsonRpcProviderError, CancelledError])
-  .} =
+  proc awaitClient: Future[RpcClient] {.async.} =
     convertError:
       await initialized
       return client
 
-  proc awaitSubscriptions(): Future[JsonRpcSubscriptions] {.
-      async: (raises: [JsonRpcProviderError, CancelledError])
-  .} =
+  proc awaitSubscriptions: Future[JsonRpcSubscriptions] {.async.} =
     convertError:
       await initialized
       return subscriptions
 
   initialized = initialize()
-  return JsonRpcProvider(client: awaitClient(), subscriptions: awaitSubscriptions(), maxPriorityFeePerGas: maxPriorityFeePerGas)
+  JsonRpcProvider(client: awaitClient(), subscriptions: awaitSubscriptions())
 
-proc callImpl(
-    client: RpcClient, call: string, args: JsonNode
-): Future[JsonNode] {.async: (raises: [JsonRpcProviderError, CancelledError]).} =
-  try:
-    let response = await client.call(call, %args)
-    without json =? JsonNode.fromJson(response.string), error:
-      raiseJsonRpcProviderError "Failed to parse response '" & response.string & "': " &
-        error.msg
-    return json
-  except CancelledError as error:
-    raise error
-  except CatchableError as error:
-    raiseJsonRpcProviderError error.msg
-
-proc send*(
-    provider: JsonRpcProvider, call: string, arguments: seq[JsonNode] = @[]
-): Future[JsonNode] {.async: (raises: [ProviderError, CancelledError]).} =
+proc send*(provider: JsonRpcProvider,
+           call: string,
+           arguments: seq[JsonNode] = @[]): Future[JsonNode] {.async.} =
   convertError:
     let client = await provider.client
-    return await client.callImpl(call, %arguments)
+    return await client.call(call, %arguments)
 
-proc listAccounts*(
-    provider: JsonRpcProvider
-): Future[seq[Address]] {.async: (raises: [JsonRpcProviderError, CancelledError]).} =
+proc listAccounts*(provider: JsonRpcProvider): Future[seq[Address]] {.async.} =
   convertError:
     let client = await provider.client
     return await client.eth_accounts()
@@ -126,119 +112,86 @@ proc getSigner*(provider: JsonRpcProvider): JsonRpcSigner =
 proc getSigner*(provider: JsonRpcProvider, address: Address): JsonRpcSigner =
   JsonRpcSigner(provider: provider, address: some address)
 
-method getBlockNumber*(
-    provider: JsonRpcProvider
-): Future[UInt256] {.async: (raises: [ProviderError, CancelledError]).} =
+method getBlockNumber*(provider: JsonRpcProvider): Future[UInt256] {.async.} =
   convertError:
     let client = await provider.client
     return await client.eth_blockNumber()
 
-method getBlock*(
-    provider: JsonRpcProvider, tag: BlockTag
-): Future[?Block] {.async: (raises: [ProviderError, CancelledError]).} =
+method getBlock*(provider: JsonRpcProvider,
+                 tag: BlockTag): Future[?Block] {.async.} =
   convertError:
     let client = await provider.client
     return await client.eth_getBlockByNumber(tag, false)
 
-method call*(
-    provider: JsonRpcProvider, tx: Transaction, blockTag = BlockTag.latest
-): Future[seq[byte]] {.async: (raises: [ProviderError, CancelledError]).} =
+method call*(provider: JsonRpcProvider,
+             tx: Transaction,
+             blockTag = BlockTag.latest): Future[seq[byte]] {.async.} =
   convertError:
     let client = await provider.client
     return await client.eth_call(tx, blockTag)
 
-method getGasPrice*(
-    provider: JsonRpcProvider
-): Future[UInt256] {.async: (raises: [ProviderError, CancelledError]).} =
+method getGasPrice*(provider: JsonRpcProvider): Future[UInt256] {.async.} =
   convertError:
     let client = await provider.client
     return await client.eth_gasPrice()
 
-method getMaxPriorityFeePerGas*(
-    provider: JsonRpcProvider
-): Future[UInt256] {.async: (raises: [CancelledError]).} =
-    try:
-      convertError:
-        let client = await provider.client
-        return await client.eth_maxPriorityFeePerGas()
-    except JsonRpcProviderError:
-      # If the provider does not provide the implementation
-      # let's just remove the manual value
-      return provider.maxPriorityFeePerGas
-
-method getTransactionCount*(
-    provider: JsonRpcProvider, address: Address, blockTag = BlockTag.latest
-): Future[UInt256] {.async: (raises: [ProviderError, CancelledError]).} =
+method getTransactionCount*(provider: JsonRpcProvider,
+                            address: Address,
+                            blockTag = BlockTag.latest):
+                           Future[UInt256] {.async.} =
   convertError:
     let client = await provider.client
     return await client.eth_getTransactionCount(address, blockTag)
 
-method getTransaction*(
-    provider: JsonRpcProvider, txHash: TransactionHash
-): Future[?PastTransaction] {.async: (raises: [ProviderError, CancelledError]).} =
+method getTransaction*(provider: JsonRpcProvider,
+                       txHash: TransactionHash):
+                      Future[?PastTransaction] {.async.} =
   convertError:
     let client = await provider.client
     return await client.eth_getTransactionByHash(txHash)
 
-method getTransactionReceipt*(
-    provider: JsonRpcProvider, txHash: TransactionHash
-): Future[?TransactionReceipt] {.async: (raises: [ProviderError, CancelledError]).} =
+method getTransactionReceipt*(provider: JsonRpcProvider,
+                              txHash: TransactionHash):
+                             Future[?TransactionReceipt] {.async.} =
   convertError:
     let client = await provider.client
     return await client.eth_getTransactionReceipt(txHash)
 
-method getLogs*(
-    provider: JsonRpcProvider, filter: EventFilter
-): Future[seq[Log]] {.async: (raises: [ProviderError, CancelledError]).} =
+method getLogs*(provider: JsonRpcProvider,
+                filter: EventFilter):
+               Future[seq[Log]] {.async.} =
   convertError:
     let client = await provider.client
-    let logsJson =
-      if filter of Filter:
-        await client.eth_getLogs(Filter(filter))
-      elif filter of FilterByBlockHash:
-        await client.eth_getLogs(FilterByBlockHash(filter))
-      else:
-        await client.eth_getLogs(filter)
+    let logsJson = if filter of Filter:
+                    await client.eth_getLogs(Filter(filter))
+                   elif filter of FilterByBlockHash:
+                    await client.eth_getLogs(FilterByBlockHash(filter))
+                   else:
+                    await client.eth_getLogs(filter)
 
     var logs: seq[Log] = @[]
     for logJson in logsJson.getElems:
-      if log =? Log.fromJson(logJson):
+      if log =? Log.fromJson(logJson).catch:
         logs.add log
 
     return logs
 
-method estimateGas*(
-    provider: JsonRpcProvider,
-    transaction: Transaction,
-    blockTag = BlockTag.latest,
-): Future[UInt256] {.async: (raises: [ProviderError, CancelledError]).} =
-  try:
-    convertError:
-      let client = await provider.client
-      return await client.eth_estimateGas(transaction, blockTag)
-  except ProviderError as error:
-    raise (ref EstimateGasError)(
-      msg: "Estimate gas failed: " & error.msg,
-      data: error.data,
-      transaction: transaction,
-      parent: error,
-    )
+method estimateGas*(provider: JsonRpcProvider,
+                    transaction: Transaction,
+                    blockTag = BlockTag.latest): Future[UInt256] {.async.} =
+  convertError:
+    let client = await provider.client
+    return await client.eth_estimateGas(transaction, blockTag)
 
-method getChainId*(
-    provider: JsonRpcProvider
-): Future[UInt256] {.async: (raises: [ProviderError, CancelledError]).} =
+method getChainId*(provider: JsonRpcProvider): Future[UInt256] {.async.} =
   convertError:
     let client = await provider.client
     try:
       return await client.eth_chainId()
-    except CancelledError as error:
-      raise error
     except CatchableError:
       return parse(await client.net_version(), UInt256)
 
-method sendTransaction*(
-    provider: JsonRpcProvider, rawTransaction: seq[byte]
-): Future[TransactionResponse] {.async: (raises: [ProviderError, CancelledError]).} =
+method sendTransaction*(provider: JsonRpcProvider, rawTransaction: seq[byte]): Future[TransactionResponse] {.async.} =
   convertError:
     let
       client = await provider.client
@@ -246,41 +199,34 @@ method sendTransaction*(
 
     return TransactionResponse(hash: hash, provider: provider)
 
-method subscribe*(
-    provider: JsonRpcProvider, filter: EventFilter, onLog: LogHandler
-): Future[Subscription] {.async: (raises: [ProviderError, CancelledError]).} =
+method subscribe*(provider: JsonRpcProvider,
+                  filter: EventFilter,
+                  onLog: LogHandler):
+                 Future[Subscription] {.async.} =
   convertError:
     let subscriptions = await provider.subscriptions
     let id = await subscriptions.subscribeLogs(filter, onLog)
     return JsonRpcSubscription(subscriptions: subscriptions, id: id)
 
-method subscribe*(
-    provider: JsonRpcProvider, onBlock: BlockHandler
-): Future[Subscription] {.async: (raises: [ProviderError, CancelledError]).} =
+method subscribe*(provider: JsonRpcProvider,
+                  onBlock: BlockHandler):
+                 Future[Subscription] {.async.} =
   convertError:
     let subscriptions = await provider.subscriptions
     let id = await subscriptions.subscribeBlocks(onBlock)
     return JsonRpcSubscription(subscriptions: subscriptions, id: id)
 
-method unsubscribe*(
-    subscription: JsonRpcSubscription
-) {.async: (raises: [ProviderError, CancelledError]).} =
+method unsubscribe(subscription: JsonRpcSubscription) {.async.} =
   convertError:
     let subscriptions = subscription.subscriptions
     let id = subscription.id
     await subscriptions.unsubscribe(id)
 
-method isSyncing*(
-    provider: JsonRpcProvider
-): Future[bool] {.async: (raises: [ProviderError, CancelledError]).} =
+method isSyncing*(provider: JsonRpcProvider): Future[bool] {.async.} =
   let response = await provider.send("eth_syncing")
-  if response.kind == JsonNodeKind.JObject:
-    return true
   return response.getBool()
 
-method close*(
-    provider: JsonRpcProvider
-) {.async: (raises: [ProviderError, CancelledError]).} =
+method close*(provider: JsonRpcProvider) {.async.} =
   convertError:
     let client = await provider.client
     let subscriptions = await provider.subscriptions
@@ -289,33 +235,10 @@ method close*(
 
 # Signer
 
-proc raiseJsonRpcSignerError(
-  message: string) {.raises: [JsonRpcSignerError].} =
-
-  var message = message
-  if json =? JsonNode.fromJson(message):
-    if "message" in json:
-      message = json{"message"}.getStr
-  raise newException(JsonRpcSignerError, message)
-
-template convertSignerError(body) =
-  try:
-    body
-  except CancelledError as error:
-    raise error
-  except JsonRpcError as error:
-    raiseJsonRpcSignerError(error.msg)
-  except CatchableError as error:
-    raise newException(JsonRpcSignerError, error.msg)
-
-method provider*(signer: JsonRpcSigner): Provider
-  {.gcsafe, raises: [SignerError].} =
-
+method provider*(signer: JsonRpcSigner): Provider =
   signer.provider
 
-method getAddress*(
-    signer: JsonRpcSigner
-): Future[Address] {.async: (raises: [ProviderError, SignerError, CancelledError]).} =
+method getAddress*(signer: JsonRpcSigner): Future[Address] {.async.} =
   if address =? signer.address:
     return address
 
@@ -323,22 +246,20 @@ method getAddress*(
   if accounts.len > 0:
     return accounts[0]
 
-  raiseJsonRpcSignerError "no address found"
+  raiseJsonRpcProviderError "no address found"
 
-method signMessage*(
-    signer: JsonRpcSigner, message: seq[byte]
-): Future[seq[byte]] {.async: (raises: [SignerError, CancelledError]).} =
-  convertSignerError:
+method signMessage*(signer: JsonRpcSigner,
+                    message: seq[byte]): Future[seq[byte]] {.async.} =
+  convertError:
     let client = await signer.provider.client
     let address = await signer.getAddress()
-    return await client.personal_sign(message, address)
+    return await client.eth_sign(address, message)
 
-method sendTransaction*(
-    signer: JsonRpcSigner, transaction: Transaction
-): Future[TransactionResponse] {.
-    async: (raises: [SignerError, ProviderError, CancelledError])
-.} =
+method sendTransaction*(signer: JsonRpcSigner,
+                        transaction: Transaction): Future[TransactionResponse] {.async.} =
   convertError:
+    if nonce =? transaction.nonce:
+      signer.updateNonce(nonce)
     let
       client = await signer.provider.client
       hash = await client.eth_sendTransaction(transaction)

ethers/providers/jsonrpc/conversions.nim

@@ -1,62 +1,76 @@
+import std/json
 import std/strformat
 import std/strutils
-import pkg/chronicles except fromJson, `%`, `%*`, toJson
-import pkg/json_rpc/jsonmarshal except toJson
-import pkg/questionable/results
-import pkg/serde
+import pkg/json_rpc/jsonmarshal
 import pkg/stew/byteutils
 import ../../basics
 import ../../transaction
 import ../../blocktag
 import ../../provider
 
-export jsonmarshal except toJson
-export serde
-export chronicles except fromJson, `%`, `%*`, toJson
+export jsonmarshal
 
-{.push raises: [].}
+type JsonSerializationError = object of EthersError
 
-proc getOrRaise*[T, E](self: ?!T, exc: typedesc[E]): T {.raises: [E].} =
-  let val = self.valueOr:
-    raise newException(E, self.error.msg)
-  val
+template raiseSerializationError(message: string) =
+  raise newException(JsonSerializationError, message)
 
-template mapFailure*[T, V, E](
-    exp: Result[T, V],
-    exc: typedesc[E],
-): Result[T, ref CatchableError] =
-  ## Convert `Result[T, E]` to `Result[E, ref CatchableError]`
-  ##
+proc expectFields(json: JsonNode, expectedFields: varargs[string]) =
+  for fieldName in expectedFields:
+    if not json.hasKey(fieldName):
+      raiseSerializationError(fmt"'{fieldName}' field not found in ${json}")
 
-  exp.mapErr(proc (e: V): ref CatchableError = (ref exc)(msg: e.msg))
+func fromJson*(T: type, json: JsonNode, name = ""): T =
+  fromJson(json, name, result)
+
+# byte sequence
+
+func `%`*(bytes: seq[byte]): JsonNode =
+  %("0x" & bytes.toHex)
+
+func fromJson*(json: JsonNode, name: string, result: var seq[byte]) =
+  result = hexToSeqByte(json.getStr())
+
+# byte arrays
+
+func `%`*[N](bytes: array[N, byte]): JsonNode =
+  %("0x" & bytes.toHex)
+
+func fromJson*[N](json: JsonNode, name: string, result: var array[N, byte]) =
+  hexToByteArray(json.getStr(), result)
 
 # Address
 
 func `%`*(address: Address): JsonNode =
   %($address)
 
-func fromJson(_: type Address, json: JsonNode): ?!Address =
-  expectJsonKind(Address, JString, json)
-  without address =? Address.init(json.getStr), error:
-    return failure newException(SerializationError,
-      "Failed to convert '" & $json & "' to Address: " & error.msg)
-  success address
+func fromJson*(json: JsonNode, name: string, result: var Address) =
+  if address =? Address.init(json.getStr()):
+    result = address
+  else:
+    raise newException(ValueError, "\""  & name & "\"is not an Address")
 
 # UInt256
 
 func `%`*(integer: UInt256): JsonNode =
   %("0x" & toHex(integer))
 
+func fromJson*(json: JsonNode, name: string, result: var UInt256) =
+  result = UInt256.fromHex(json.getStr())
+
+# TransactionType
+
+func fromJson*(json: JsonNode, name: string, result: var TransactionType) =
+  let val = fromHex[int](json.getStr)
+  result = TransactionType(val)
+
+func `%`*(txType: TransactionType): JsonNode =
+  %("0x" & txType.int.toHex(1))
+
 # Transaction
 
-# TODO: add option that ignores none Option[T]
-# TODO: add name option (gasLimit => gas, sender => from)
 func `%`*(transaction: Transaction): JsonNode =
-  result = %*{
-    "to": transaction.to,
-    "data": %transaction.data,
-    "value": %transaction.value
-  }
+  result = %{ "to": %transaction.to, "data": %transaction.data }
   if sender =? transaction.sender:
     result["from"] = %sender
   if nonce =? transaction.nonce:
@@ -70,53 +84,105 @@ func `%`*(transaction: Transaction): JsonNode =
 
 # BlockTag
 
-func `%`*(tag: BlockTag): JsonNode =
-  % $tag
+func `%`*(blockTag: BlockTag): JsonNode =
+  %($blockTag)
 
-func fromJson*(_: type BlockTag, json: JsonNode): ?!BlockTag =
-  expectJsonKind(BlockTag, JString, json)
-  let jsonVal = json.getStr
-  if jsonVal.len >= 2 and jsonVal[0..1].toLowerAscii == "0x":
-    without blkNum =? UInt256.fromHex(jsonVal).catch, error:
-      return BlockTag.failure error.msg
-    return success BlockTag.init(blkNum)
+# Log
 
-  case jsonVal:
-  of "earliest": return success BlockTag.earliest
-  of "latest": return success BlockTag.latest
-  of "pending": return success BlockTag.pending
-  else: return failure newException(SerializationError,
-      "Failed to convert '" & $json &
-      "' to BlockTag: must be one of 'earliest', 'latest', 'pending'")
+func fromJson*(json: JsonNode, name: string, result: var Log) =
+  if not (json.hasKey("data") and json.hasKey("topics")):
+    raise newException(ValueError, "'data' and/or 'topics' fields not found")
 
-# TransactionStatus | TransactionType
-type TransactionEnums = TransactionStatus | TransactionType
+  var data: seq[byte]
+  var topics: seq[Topic]
+  fromJson(json["data"], "data", data)
+  fromJson(json["topics"], "topics", topics)
+  result = Log(data: data, topics: topics)
 
-func `%`*(e: TransactionEnums): JsonNode =
-  % ("0x" & e.int8.toHex(1))
+# TransactionStatus
 
-proc fromJson*(
-  T: type TransactionEnums,
-  json: JsonNode
-): ?!T =
-  expectJsonKind(string, JString, json)
-  let integer = ? fromHex[int](json.str).catch.mapFailure(SerializationError)
-  success T(integer)
+func fromJson*(json: JsonNode, name: string, result: var TransactionStatus) =
+  let val = fromHex[int](json.getStr)
+  result = TransactionStatus(val)
 
-## Generic conversions to use nim-json instead of nim-json-serialization for
-## json rpc serialization purposes
-##  writeValue => `%`
-##  readValue  => fromJson
+func `%`*(status: TransactionStatus): JsonNode =
+  %("0x" & status.int.toHex(1))
 
-proc writeValue*[T: not JsonNode](
-  writer: var JsonWriter[JrpcConv],
-  value: T) {.raises:[IOError].} =
+# PastTransaction
 
-  writer.writeValue(%value)
+func fromJson*(json: JsonNode, name: string, result: var PastTransaction) =
+  # Deserializes a past transaction, eg eth_getTransactionByHash.
+  # Spec: https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_gettransactionbyhash
+  json.expectFields "blockHash", "blockNumber", "from", "gas", "gasPrice",
+                    "hash", "input", "nonce", "to", "transactionIndex", "value",
+                    "v", "r", "s"
 
-proc readValue*[T: not JsonNode](
-  r: var JsonReader[JrpcConv],
-  result: var T) {.raises: [SerializationError, IOError].} =
+  result = PastTransaction(
+    blockHash: BlockHash.fromJson(json["blockHash"], "blockHash"),
+    blockNumber: UInt256.fromJson(json["blockNumber"], "blockNumber"),
+    sender: Address.fromJson(json["from"], "from"),
+    gas: UInt256.fromJson(json["gas"], "gas"),
+    gasPrice: UInt256.fromJson(json["gasPrice"], "gasPrice"),
+    hash: TransactionHash.fromJson(json["hash"], "hash"),
+    input: seq[byte].fromJson(json["input"], "input"),
+    nonce: UInt256.fromJson(json["nonce"], "nonce"),
+    to: Address.fromJson(json["to"], "to"),
+    transactionIndex: UInt256.fromJson(json["transactionIndex"], "transactionIndex"),
+    value: UInt256.fromJson(json["value"], "value"),
+    v: UInt256.fromJson(json["v"], "v"),
+    r: UInt256.fromJson(json["r"], "r"),
+    s: UInt256.fromJson(json["s"], "s"),
+  )
+  if json.hasKey("type"):
+    result.transactionType = fromJson(?TransactionType, json["type"], "type")
+  if json.hasKey("chainId"):
+    result.chainId = fromJson(?UInt256, json["chainId"], "chainId")
 
-  var json = r.readValue(JsonNode)
-  result = T.fromJson(json).getOrRaise(SerializationError)
+func `%`*(tx: PastTransaction): JsonNode =
+  let json = %*{
+    "blockHash": tx.blockHash,
+    "blockNumber": tx.blockNumber,
+    "from": tx.sender,
+    "gas": tx.gas,
+    "gasPrice": tx.gasPrice,
+    "hash": tx.hash,
+    "input": tx.input,
+    "nonce": tx.nonce,
+    "to": tx.to,
+    "transactionIndex": tx.transactionIndex,
+    "value": tx.value,
+    "v": tx.v,
+    "r": tx.r,
+    "s": tx.s
+  }
+  if txType =? tx.transactionType:
+    json["type"] = %txType
+  if chainId =? tx.chainId:
+    json["chainId"] = %chainId
+  return json
+
+# TransactionReceipt
+
+func fromJson*(json: JsonNode, name: string, result: var TransactionReceipt) =
+  # Deserializes a transaction receipt, eg eth_getTransactionReceipt.
+  # Spec: https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_gettransactionreceipt
+  json.expectFields "transactionHash", "transactionIndex", "cumulativeGasUsed",
+                    "effectiveGasPrice", "gasUsed", "logs", "logsBloom", "type",
+                    "status"
+
+  result = TransactionReceipt(
+    transactionHash: fromJson(TransactionHash, json["transactionHash"], "transactionHash"),
+    transactionIndex: UInt256.fromJson(json["transactionIndex"], "transactionIndex"),
+    blockHash: fromJson(?BlockHash, json["blockHash"], "blockHash"),
+    blockNumber: fromJson(?UInt256, json["blockNumber"], "blockNumber"),
+    sender: fromJson(?Address, json["from"], "from"),
+    to: fromJson(?Address, json["to"], "to"),
+    cumulativeGasUsed: UInt256.fromJson(json["cumulativeGasUsed"], "cumulativeGasUsed"),
+    effectiveGasPrice: fromJson(?UInt256, json["effectiveGasPrice"], "effectiveGasPrice"),
+    gasUsed: UInt256.fromJson(json["gasUsed"], "gasUsed"),
+    contractAddress: fromJson(?Address, json["contractAddress"], "contractAddress"),
+    logs: seq[Log].fromJson(json["logs"], "logs"),
+    logsBloom: seq[byte].fromJson(json["logsBloom"], "logsBloom"),
+    transactionType: TransactionType.fromJson(json["type"], "type"),
+    status: TransactionStatus.fromJson(json["status"], "status")
+  )

ethers/providers/jsonrpc/errors.nim

@@ -1,49 +0,0 @@
-import std/strutils
-import pkg/stew/byteutils
-import ../../basics
-import ../../errors
-import ../../provider
-import ./conversions
-
-export errors
-
-{.push raises:[].}
-
-type JsonRpcProviderError* = object of ProviderError
-
-func extractErrorData(json: JsonNode): ?seq[byte] =
-  if json.kind == JObject:
-    if "message" in json and "data" in json:
-      let message = json{"message"}.getStr()
-      let hex = json{"data"}.getStr()
-      if "reverted" in message and hex.startsWith("0x"):
-        if data =? hexToSeqByte(hex).catch:
-          return some data
-    for key in json.keys:
-      if data =? extractErrorData(json{key}):
-        return some data
-
-func new*(_: type JsonRpcProviderError, json: JsonNode): ref JsonRpcProviderError =
-  let error = (ref JsonRpcProviderError)()
-  if "message" in json:
-    error.msg = json{"message"}.getStr
-  error.data = extractErrorData(json)
-  error
-
-proc raiseJsonRpcProviderError*(
-  message: string) {.raises: [JsonRpcProviderError].} =
-  if json =? JsonNode.fromJson(message):
-    raise JsonRpcProviderError.new(json)
-  else:
-    raise newException(JsonRpcProviderError, message)
-
-template convertError*(body) =
-  try:
-    body
-  except CancelledError as error:
-    raise error
-  except JsonRpcError as error:
-    raiseJsonRpcProviderError(error.msg)
-  except CatchableError as error:
-    raiseJsonRpcProviderError(error.msg)
-

ethers/providers/jsonrpc/looping.nim

@@ -2,5 +2,5 @@ template untilCancelled*(body) =
   try:
     while true:
       body
-  except CancelledError as e:
-    raise e
+  except CancelledError:
+    raise

ethers/providers/jsonrpc/signatures.nim

@@ -1,5 +1,4 @@
 proc net_version(): string
-proc personal_sign(message: seq[byte], account: Address): seq[byte]
 proc eth_accounts: seq[Address]
 proc eth_blockNumber: UInt256
 proc eth_call(transaction: Transaction, blockTag: BlockTag): seq[byte]
@@ -14,6 +13,7 @@ proc eth_chainId(): UInt256
 proc eth_sendTransaction(transaction: Transaction): TransactionHash
 proc eth_sendRawTransaction(data: seq[byte]): TransactionHash
 proc eth_getTransactionReceipt(hash: TransactionHash): ?TransactionReceipt
+proc eth_sign(account: Address, message: seq[byte]): seq[byte]
 proc eth_subscribe(name: string, filter: EventFilter): JsonNode
 proc eth_subscribe(name: string): JsonNode
 proc eth_unsubscribe(id: JsonNode): bool
@@ -21,4 +21,3 @@ proc eth_newBlockFilter(): JsonNode
 proc eth_newFilter(filter: EventFilter): JsonNode
 proc eth_getFilterChanges(id: JsonNode): JsonNode
 proc eth_uninstallFilter(id: JsonNode): bool
-proc eth_maxPriorityFeePerGas(): UInt256

ethers/providers/jsonrpc/subscriptions.nim

@@ -1,379 +1,168 @@
 import std/tables
 import std/sequtils
-import std/strutils
 import pkg/chronos
-import pkg/questionable
 import pkg/json_rpc/rpcclient
-import pkg/serde
 import ../../basics
-import ../../errors
 import ../../provider
-include ../../nimshims/hashes
 import ./rpccalls
 import ./conversions
-
-export serde
+import ./looping
 
 type
   JsonRpcSubscriptions* = ref object of RootObj
     client: RpcClient
     callbacks: Table[JsonNode, SubscriptionCallback]
-    methodHandlers: Table[string, MethodHandler]
-    # Used by both PollingSubscriptions and WebsocketSubscriptions to store
-    # subscription filters so the subscriptions can be recreated. With
-    # PollingSubscriptions, the RPC node might prune/forget about them, and with
-    # WebsocketSubscriptions, when using hardhat, subscriptions are dropped after 5
-    # minutes.
-    logFilters: Table[JsonNode, EventFilter]
-  MethodHandler* = proc (j: JsonNode) {.gcsafe, raises: [].}
-  SubscriptionCallback = proc(id: JsonNode, arguments: ?!JsonNode) {.gcsafe, raises:[].}
-
-{.push raises:[].}
-
-template convertErrorsToSubscriptionError(body) =
-  try:
-    body
-  except CancelledError as error:
-    raise error
-  except CatchableError as error:
-    raise error.toErr(SubscriptionError)
-
-template `or`(a: JsonNode, b: typed): JsonNode =
-  if a.isNil: b else: a
-
-func start*(subscriptions: JsonRpcSubscriptions) =
-  subscriptions.client.onProcessMessage =
-    proc(client: RpcClient,
-         line: string): Result[bool, string] {.gcsafe, raises: [].} =
-      if json =? JsonNode.fromJson(line):
-        if "method" in json:
-          let methodName = json{"method"}.getStr()
-          if methodName in subscriptions.methodHandlers:
-            let handler = subscriptions.methodHandlers.getOrDefault(methodName)
-            if not handler.isNil:
-              handler(json{"params"} or newJArray())
-              # false = do not continue processing message using json_rpc's
-              # default processing handler
-              return ok false
-
-      # true = continue processing message using json_rpc's default message handler
-      return ok true
-
-proc setMethodHandler(
-  subscriptions: JsonRpcSubscriptions,
-  `method`: string,
-  handler: MethodHandler
-) =
-  subscriptions.methodHandlers[`method`] = handler
+  SubscriptionCallback = proc(id, arguments: JsonNode) {.gcsafe, raises:[].}
 
 method subscribeBlocks*(subscriptions: JsonRpcSubscriptions,
                         onBlock: BlockHandler):
                        Future[JsonNode]
-                       {.async: (raises: [SubscriptionError, CancelledError]), base,.} =
+                       {.async, base.} =
   raiseAssert "not implemented"
 
 method subscribeLogs*(subscriptions: JsonRpcSubscriptions,
                       filter: EventFilter,
                       onLog: LogHandler):
                      Future[JsonNode]
-                     {.async: (raises: [SubscriptionError, CancelledError]), base.} =
+                     {.async, base.} =
   raiseAssert "not implemented"
 
 method unsubscribe*(subscriptions: JsonRpcSubscriptions,
                     id: JsonNode)
-                   {.async: (raises: [CancelledError]), base.} =
-  raiseAssert "not implemented "
+                   {.async, base.} =
+  raiseAssert "not implemented"
 
-method close*(subscriptions: JsonRpcSubscriptions) {.async: (raises: []), base.} =
+method close*(subscriptions: JsonRpcSubscriptions) {.async, base.} =
   let ids = toSeq subscriptions.callbacks.keys
   for id in ids:
-    try:
-      await subscriptions.unsubscribe(id)
-    except CatchableError as e:
-      error "JsonRpc unsubscription failed", error = e.msg, id = id
+    await subscriptions.unsubscribe(id)
 
 proc getCallback(subscriptions: JsonRpcSubscriptions,
-                 id: JsonNode): ?SubscriptionCallback  {. raises:[].} =
+                 id: JsonNode): ?SubscriptionCallback =
   try:
-    if not id.isNil and id in subscriptions.callbacks:
-      return subscriptions.callbacks[id].some
-  except: discard
+    if subscriptions.callbacks.hasKey(id):
+      subscriptions.callbacks[id].some
+    else:
+      SubscriptionCallback.none
+  except Exception:
+    SubscriptionCallback.none
 
 # Web sockets
 
-# Default re-subscription period is seconds
-const WsResubscribe {.intdefine.}: int = 0
-
 type
   WebSocketSubscriptions = ref object of JsonRpcSubscriptions
-    logFiltersLock: AsyncLock
-    resubscribeFut: Future[void]
-    resubscribeInterval: int
-
-template withLock*(subscriptions: WebSocketSubscriptions, body: untyped) =
-  if subscriptions.logFiltersLock.isNil:
-    subscriptions.logFiltersLock = newAsyncLock()
-
-  await subscriptions.logFiltersLock.acquire()
-  try:
-    body
-  finally:
-    subscriptions.logFiltersLock.release()
-
-# This is a workaround to manage the 5 minutes limit due to hardhat.
-# See https://github.com/NomicFoundation/hardhat/issues/2053#issuecomment-1061374064
-proc resubscribeWebsocketEventsOnTimeout*(subscriptions: WebsocketSubscriptions) {.async: (raises: [CancelledError]).} =
-  while true:
-    await sleepAsync(subscriptions.resubscribeInterval.seconds)
-    try:
-      withLock(subscriptions):
-        for id, callback in subscriptions.callbacks:
-
-          var newId: JsonNode
-          if id in subscriptions.logFilters:
-            let filter = subscriptions.logFilters[id]
-            newId = await subscriptions.client.eth_subscribe("logs", filter)
-            subscriptions.logFilters[newId] = filter
-            subscriptions.logFilters.del(id)
-          else:
-            newId = await subscriptions.client.eth_subscribe("newHeads")
-
-          subscriptions.callbacks[newId] = callback
-          subscriptions.callbacks.del(id)
-          discard await subscriptions.client.eth_unsubscribe(id)
-    except CancelledError as e:
-      raise e
-    except CatchableError as e:
-      error "WS resubscription failed" , error = e.msg
 
 proc new*(_: type JsonRpcSubscriptions,
-            client: RpcWebSocketClient,
-            resubscribeInterval = WsResubscribe): JsonRpcSubscriptions =
-  let subscriptions = WebSocketSubscriptions(client: client, resubscribeInterval: resubscribeInterval)
-
+          client: RpcWebSocketClient): JsonRpcSubscriptions =
+  let subscriptions = WebSocketSubscriptions(client: client)
   proc subscriptionHandler(arguments: JsonNode) {.raises:[].} =
-    let id = arguments{"subscription"} or newJString("")
-    if callback =? subscriptions.getCallback(id):
-      callback(id, success(arguments))
-  subscriptions.setMethodHandler("eth_subscription", subscriptionHandler)
-
-  if resubscribeInterval > 0:
-    if resubscribeInterval >= 300:
-      warn "Resubscription interval greater than 300 seconds is useless for hardhat workaround", resubscribeInterval = resubscribeInterval
-
-    subscriptions.resubscribeFut = resubscribeWebsocketEventsOnTimeout(subscriptions)
-
+    if id =? arguments["subscription"].catch and
+       callback =? subscriptions.getCallback(id):
+      callback(id, arguments)
+  client.setMethodHandler("eth_subscription", subscriptionHandler)
   subscriptions
 
 method subscribeBlocks(subscriptions: WebSocketSubscriptions,
                        onBlock: BlockHandler):
                       Future[JsonNode]
-                      {.async: (raises: [SubscriptionError, CancelledError]).} =
-  proc callback(id: JsonNode, argumentsResult: ?!JsonNode) {.raises: [].} =
-    without arguments =? argumentsResult, error:
-      onBlock(failure(Block, error.toErr(SubscriptionError)))
-      return
-
-    let res = Block.fromJson(arguments{"result"}).mapFailure(SubscriptionError)
-    onBlock(res)
-
-  convertErrorsToSubscriptionError:
-    withLock(subscriptions):
-      let id = await subscriptions.client.eth_subscribe("newHeads")
-      subscriptions.callbacks[id] = callback
-      return id
+                      {.async.} =
+  proc callback(id, arguments: JsonNode) =
+    if blck =? Block.fromJson(arguments["result"]).catch:
+      onBlock(blck)
+  let id = await subscriptions.client.eth_subscribe("newHeads")
+  subscriptions.callbacks[id] = callback
+  return id
 
 method subscribeLogs(subscriptions: WebSocketSubscriptions,
                      filter: EventFilter,
                      onLog: LogHandler):
                     Future[JsonNode]
-                    {.async: (raises: [SubscriptionError, CancelledError]).} =
-  proc callback(id: JsonNode, argumentsResult: ?!JsonNode) =
-    without arguments =? argumentsResult, error:
-      onLog(failure(Log, error.toErr(SubscriptionError)))
-      return
+                    {.async.} =
+  proc callback(id, arguments: JsonNode) =
+    if log =? Log.fromJson(arguments["result"]).catch:
+      onLog(log)
+  let id = await subscriptions.client.eth_subscribe("logs", filter)
+  subscriptions.callbacks[id] = callback
+  return id
 
-    let res = Log.fromJson(arguments{"result"}).mapFailure(SubscriptionError)
-    onLog(res)
-
-  convertErrorsToSubscriptionError:
-    withLock(subscriptions):
-      let id = await subscriptions.client.eth_subscribe("logs", filter)
-      subscriptions.callbacks[id] = callback
-      subscriptions.logFilters[id] = filter
-      return id
-
-method unsubscribe*(subscriptions: WebSocketSubscriptions,
+method unsubscribe(subscriptions: WebSocketSubscriptions,
                    id: JsonNode)
-                  {.async: (raises: [CancelledError]).} =
-  try:
-    withLock(subscriptions):
-      subscriptions.callbacks.del(id)
-      discard await subscriptions.client.eth_unsubscribe(id)
-  except CancelledError as e:
-    raise e
-  except CatchableError:
-    # Ignore if uninstallation of the subscribiton fails.
-    discard
-
-method close*(subscriptions: WebSocketSubscriptions) {.async: (raises: []).} =
-  await procCall JsonRpcSubscriptions(subscriptions).close()
-  if not subscriptions.resubscribeFut.isNil:
-      await subscriptions.resubscribeFut.cancelAndWait()
+                  {.async.} =
+  subscriptions.callbacks.del(id)
+  discard await subscriptions.client.eth_unsubscribe(id)
 
 # Polling
 
 type
-  PollingSubscriptions* = ref object of JsonRpcSubscriptions
+  PollingSubscriptions = ref object of JsonRpcSubscriptions
     polling: Future[void]
 
-    # Used when filters are recreated to translate from the id that user
-    # originally got returned to new filter id
-    subscriptionMapping: Table[JsonNode, JsonNode]
-
 proc new*(_: type JsonRpcSubscriptions,
           client: RpcHttpClient,
           pollingInterval = 4.seconds): JsonRpcSubscriptions =
 
   let subscriptions = PollingSubscriptions(client: client)
 
-  proc resubscribe(id: JsonNode): Future[?!void] {.async: (raises: [CancelledError]).} =
+  proc getChanges(id: JsonNode): Future[JsonNode] {.async.} =
     try:
-      var newId: JsonNode
-      # Log filters are stored in logFilters, block filters are not persisted
-      # there is they do not need any specific data for their recreation.
-      # We use this to determine if the filter was log or block filter here.
-      if subscriptions.logFilters.hasKey(id):
-        let filter = subscriptions.logFilters[id]
-        newId = await subscriptions.client.eth_newFilter(filter)
-      else:
-        newId = await subscriptions.client.eth_newBlockFilter()
-      subscriptions.subscriptionMapping[id] = newId
-    except CancelledError as e:
-      raise e
-    except CatchableError as e:
-      return failure(void, e.toErr(SubscriptionError, "HTTP polling: There was an exception while getting subscription changes: " & e.msg))
+      return await subscriptions.client.eth_getFilterChanges(id)
+    except CatchableError:
+      return newJArray()
 
-    return success()
+  proc poll(id: JsonNode) {.async.} =
+    for change in await getChanges(id):
+      if callback =? subscriptions.getCallback(id):
+        callback(id, change)
 
-  proc getChanges(id: JsonNode): Future[?!JsonNode] {.async: (raises: [CancelledError]).} =
-    if mappedId =? subscriptions.subscriptionMapping.?[id]:
-      try:
-        let changes = await subscriptions.client.eth_getFilterChanges(mappedId)
-        if changes.kind == JArray:
-          return success(changes)
-      except JsonRpcError as e:
-        if error =? (await resubscribe(id)).errorOption:
-          return failure(JsonNode, error)
-
-        # TODO: we could still miss some events between losing the subscription
-        # and resubscribing. We should probably adopt a strategy like ethers.js,
-        # whereby we keep track of the latest block number that we've seen
-        # filter changes for:
-        # https://github.com/ethers-io/ethers.js/blob/f97b92bbb1bde22fcc44100af78d7f31602863ab/packages/providers/src.ts/base-provider.ts#L977
-
-        if not ("filter not found" in e.msg):
-          return failure(JsonNode, e.toErr(SubscriptionError, "HTTP polling: There was an exception while getting subscription changes: " & e.msg))
-      except CancelledError as e:
-        raise e
-      except SubscriptionError as e:
-        return failure(JsonNode, e)
-      except CatchableError as e:
-        return failure(JsonNode, e.toErr(SubscriptionError, "HTTP polling: There was an exception while getting subscription changes: " & e.msg))
-    return success(newJArray())
-
-  proc poll(id: JsonNode) {.async: (raises: [CancelledError]).} =
-    without callback =? subscriptions.getCallback(id):
-      return
-
-    without changes =? (await getChanges(id)), error:
-      callback(id, failure(JsonNode, error))
-      return
-
-    for change in changes:
-      callback(id, success(change))
-
-  proc poll {.async: (raises: []).} =
-    try:
-      while true:
-        for id in toSeq subscriptions.callbacks.keys:
-          await poll(id)
-        await sleepAsync(pollingInterval)
-    except CancelledError:
-      discard
+  proc poll {.async.} =
+    untilCancelled:
+      for id in toSeq subscriptions.callbacks.keys:
+        await poll(id)
+      await sleepAsync(pollingInterval)
 
   subscriptions.polling = poll()
-  asyncSpawn subscriptions.polling
   subscriptions
 
-method close*(subscriptions: PollingSubscriptions) {.async: (raises: []).} =
+method close*(subscriptions: PollingSubscriptions) {.async.} =
   await subscriptions.polling.cancelAndWait()
   await procCall JsonRpcSubscriptions(subscriptions).close()
 
 method subscribeBlocks(subscriptions: PollingSubscriptions,
                        onBlock: BlockHandler):
                       Future[JsonNode]
-                      {.async: (raises: [SubscriptionError, CancelledError]).} =
+                      {.async.} =
 
-  proc getBlock(hash: BlockHash) {.async: (raises:[]).} =
+  proc getBlock(hash: BlockHash) {.async.} =
     try:
       if blck =? (await subscriptions.client.eth_getBlockByHash(hash, false)):
-        onBlock(success(blck))
-    except CancelledError:
+        onBlock(blck)
+    except CatchableError:
       discard
-    except CatchableError as e:
-      let error = e.toErr(SubscriptionError, "HTTP polling: There was an exception while getting subscription's block: " & e.msg)
-      onBlock(failure(Block, error))
 
-  proc callback(id: JsonNode, changeResult: ?!JsonNode) {.raises:[].} =
-    without change =? changeResult, e:
-      onBlock(failure(Block, e.toErr(SubscriptionError)))
-      return
-
-    if hash =? BlockHash.fromJson(change):
+  proc callback(id, change: JsonNode) =
+    if hash =? BlockHash.fromJson(change).catch:
       asyncSpawn getBlock(hash)
 
-  convertErrorsToSubscriptionError:
-    let id = await subscriptions.client.eth_newBlockFilter()
-    subscriptions.callbacks[id] = callback
-    subscriptions.subscriptionMapping[id] = id
-    return id
+  let id = await subscriptions.client.eth_newBlockFilter()
+  subscriptions.callbacks[id] = callback
+  return id
 
 method subscribeLogs(subscriptions: PollingSubscriptions,
                      filter: EventFilter,
                      onLog: LogHandler):
                     Future[JsonNode]
-                    {.async: (raises: [SubscriptionError, CancelledError]).} =
+                    {.async.} =
 
-  proc callback(id: JsonNode, argumentsResult: ?!JsonNode) =
-    without arguments =? argumentsResult, error:
-      onLog(failure(Log, error.toErr(SubscriptionError)))
-      return
+  proc callback(id, change: JsonNode) =
+    if log =? Log.fromJson(change).catch:
+      onLog(log)
 
-    let res = Log.fromJson(arguments).mapFailure(SubscriptionError)
-    onLog(res)
+  let id = await subscriptions.client.eth_newFilter(filter)
+  subscriptions.callbacks[id] = callback
+  return id
 
-  convertErrorsToSubscriptionError:
-    let id = await subscriptions.client.eth_newFilter(filter)
-    subscriptions.callbacks[id] = callback
-    subscriptions.logFilters[id] = filter
-    subscriptions.subscriptionMapping[id] = id
-    return id
-
-method unsubscribe*(subscriptions: PollingSubscriptions,
+method unsubscribe(subscriptions: PollingSubscriptions,
                    id: JsonNode)
-                  {.async: (raises: [CancelledError]).} =
-  try:
-    subscriptions.logFilters.del(id)
-    subscriptions.callbacks.del(id)
-    if sub =? subscriptions.subscriptionMapping.?[id]:
-      subscriptions.subscriptionMapping.del(id)
-      discard await subscriptions.client.eth_uninstallFilter(sub)
-  except CancelledError as e:
-    raise e
-  except CatchableError:
-    # Ignore if uninstallation of the filter fails. If it's the last step in our
-    # cleanup, then filter changes for this filter will no longer be polled so
-    # if the filter continues to live on in geth for whatever reason then it
-    # doesn't matter.
-    discard
+                  {.async.} =
+  subscriptions.callbacks.del(id)
+  discard await subscriptions.client.eth_uninstallFilter(id)

ethers/signer.nim

@@ -1,184 +1,144 @@
-import pkg/questionable
-import pkg/chronicles
 import ./basics
-import ./errors
 import ./provider
 
 export basics
-export errors
-
-{.push raises: [].}
 
 type
   Signer* = ref object of RootObj
+    lastSeenNonce: ?UInt256
     populateLock: AsyncLock
 
-template raiseSignerError*(message: string, parent: ref CatchableError = nil) =
+type
+  SignerError* = object of EthersError
+  EstimateGasError* = object of SignerError
+    transaction*: Transaction
+
+template raiseSignerError(message: string, parent: ref ProviderError = nil) =
   raise newException(SignerError, message, parent)
 
-template convertError(body) =
-  try:
-    body
-  except CancelledError as error:
-    raise error
-  except ProviderError as error:
-    raise error # do not convert provider errors
-  except CatchableError as error:
-    raiseSignerError(error.msg)
+proc raiseEstimateGasError(
+  transaction: Transaction,
+  parent: ref ProviderError = nil
+) =
+  let e = (ref EstimateGasError)(
+    msg: "Estimate gas failed",
+    transaction: transaction,
+    parent: parent)
+  raise e
 
-method provider*(
-  signer: Signer): Provider {.base, gcsafe, raises: [SignerError].} =
+method provider*(signer: Signer): Provider {.base, gcsafe.} =
   doAssert false, "not implemented"
 
-method getAddress*(
-    signer: Signer
-): Future[Address] {.
-    base, async: (raises: [ProviderError, SignerError, CancelledError])
-.} =
+method getAddress*(signer: Signer): Future[Address] {.base, gcsafe.} =
   doAssert false, "not implemented"
 
-method signMessage*(
-    signer: Signer, message: seq[byte]
-): Future[seq[byte]] {.base, async: (raises: [SignerError, CancelledError]).} =
+method signMessage*(signer: Signer,
+                    message: seq[byte]): Future[seq[byte]] {.base, async.} =
   doAssert false, "not implemented"
 
-method sendTransaction*(
-    signer: Signer, transaction: Transaction
-): Future[TransactionResponse] {.
-    base, async: (raises: [SignerError, ProviderError, CancelledError])
-.} =
+method sendTransaction*(signer: Signer,
+                        transaction: Transaction): Future[TransactionResponse] {.base, async.} =
   doAssert false, "not implemented"
 
-method getGasPrice*(
-    signer: Signer
-): Future[UInt256] {.
-    base, async: (raises: [ProviderError, SignerError, CancelledError])
-.} =
-  return await signer.provider.getGasPrice()
+method getGasPrice*(signer: Signer): Future[UInt256] {.base, gcsafe.} =
+  signer.provider.getGasPrice()
 
-method getMaxPriorityFeePerGas*(
-    signer: Signer
-): Future[UInt256] {.async: (raises: [SignerError, CancelledError]).} =
-  return await signer.provider.getMaxPriorityFeePerGas()
+method getTransactionCount*(signer: Signer,
+                            blockTag = BlockTag.latest):
+                           Future[UInt256] {.base, async.} =
+  let address = await signer.getAddress()
+  return await signer.provider.getTransactionCount(address, blockTag)
 
-method getTransactionCount*(
-    signer: Signer, blockTag = BlockTag.latest
-): Future[UInt256] {.
-    base, async: (raises: [SignerError, ProviderError, CancelledError])
-.} =
-  convertError:
-    let address = await signer.getAddress()
-    return await signer.provider.getTransactionCount(address, blockTag)
-
-method estimateGas*(
-    signer: Signer, transaction: Transaction, blockTag = BlockTag.latest
-): Future[UInt256] {.
-    base, async: (raises: [SignerError, ProviderError, CancelledError])
-.} =
+method estimateGas*(signer: Signer,
+                    transaction: Transaction,
+                    blockTag = BlockTag.latest): Future[UInt256] {.base, async.} =
   var transaction = transaction
-  transaction.sender = some(await signer.getAddress())
-  return await signer.provider.estimateGas(transaction, blockTag)
-
-method getChainId*(
-    signer: Signer
-): Future[UInt256] {.
-    base, async: (raises: [SignerError, ProviderError, CancelledError])
-.} =
-  return await signer.provider.getChainId()
-
-method getNonce(
-    signer: Signer
-): Future[UInt256] {.
-    base, async: (raises: [SignerError, ProviderError, CancelledError])
-.} =
-  return await signer.getTransactionCount(BlockTag.pending)
-
-template withLock*(signer: Signer, body: untyped) =
-  if signer.populateLock.isNil:
-    signer.populateLock = newAsyncLock()
-
-  await signer.populateLock.acquire()
+  transaction.sender = some(await signer.getAddress)
   try:
-    body
-  finally:
-    try:
-      signer.populateLock.release()
-    except AsyncLockError as e:
-      raiseSignerError e.msg, e
+    return await signer.provider.estimateGas(transaction)
+  except ProviderError as e:
+    raiseEstimateGasError transaction, e
 
-method populateTransaction*(
+method getChainId*(signer: Signer): Future[UInt256] {.base, gcsafe.} =
+  signer.provider.getChainId()
+
+method getNonce(signer: Signer): Future[UInt256] {.base, gcsafe, async.} =
+  var nonce = await signer.getTransactionCount(BlockTag.pending)
+
+  if lastSeen =? signer.lastSeenNonce and lastSeen >= nonce:
+    nonce = (lastSeen + 1.u256)
+  signer.lastSeenNonce = some nonce
+
+  return nonce
+
+method updateNonce*(
   signer: Signer,
-  transaction: Transaction): Future[Transaction]
-  {.base, async: (raises: [CancelledError, ProviderError, SignerError]).} =
-  ## Populates a transaction with sender, chainId, gasPrice, nonce, and gasLimit.
-  ## NOTE: to avoid async concurrency issues, this routine should be called with
-  ## a lock if it is followed by sendTransaction. For reference, see the `send`
-  ## function in contract.nim.
+  nonce: UInt256
+) {.base, gcsafe.} =
 
-  var address: Address
-  convertError:
-    address = await signer.getAddress()
+  without lastSeen =? signer.lastSeenNonce:
+    signer.lastSeenNonce = some nonce
+    return
 
-  if sender =? transaction.sender and sender != address:
+  if nonce > lastSeen:
+    signer.lastSeenNonce = some nonce
+
+method decreaseNonce*(signer: Signer) {.base, gcsafe.} =
+  if lastSeen =? signer.lastSeenNonce and lastSeen > 0:
+    signer.lastSeenNonce = some lastSeen - 1
+
+method populateTransaction*(signer: Signer,
+                            transaction: Transaction):
+                           Future[Transaction] {.base, async.} =
+
+  if sender =? transaction.sender and sender != await signer.getAddress():
     raiseSignerError("from address mismatch")
   if chainId =? transaction.chainId and chainId != await signer.getChainId():
     raiseSignerError("chain id mismatch")
 
+  if signer.populateLock.isNil:
+    signer.populateLock = newAsyncLock()
+
+  await signer.populateLock.acquire()
+
   var populated = transaction
 
-  if transaction.sender.isNone:
-    populated.sender = some(address)
-  if transaction.chainId.isNone:
-    populated.chainId = some(await signer.getChainId())
+  try:
+    if transaction.sender.isNone:
+      populated.sender = some(await signer.getAddress())
+    if transaction.chainId.isNone:
+      populated.chainId = some(await signer.getChainId())
+    if transaction.gasPrice.isNone and (transaction.maxFee.isNone or transaction.maxPriorityFee.isNone):
+      populated.gasPrice = some(await signer.getGasPrice())
 
-  let blk = await signer.provider.getBlock(BlockTag.latest)
+    if transaction.nonce.isNone and transaction.gasLimit.isNone:
+      # when both nonce and gasLimit are not populated, we must ensure getNonce is
+      # followed by an estimateGas so we can determine if there was an error. If
+      # there is an error, the nonce must be decreased to prevent nonce gaps and
+      # stuck transactions
+      populated.nonce = some(await signer.getNonce())
+      try:
+        populated.gasLimit = some(await signer.estimateGas(populated))
+      except ProviderError, EstimateGasError:
+        let e = getCurrentException()
+        signer.decreaseNonce()
+        raise e
 
-  if baseFeePerGas =? blk.?baseFeePerGas:
-    let maxPriorityFeePerGas = transaction.maxPriorityFeePerGas |? (await signer.provider.getMaxPriorityFeePerGas())
-    populated.maxPriorityFeePerGas = some(maxPriorityFeePerGas)
+    else:
+      if transaction.nonce.isNone:
+        populated.nonce = some(await signer.getNonce())
+      if transaction.gasLimit.isNone:
+        populated.gasLimit = some(await signer.estimateGas(populated))
 
-    # Multiply by 2 because during times of congestion, baseFeePerGas can increase by 12.5% per block.
-    # https://github.com/ethers-io/ethers.js/discussions/3601#discussioncomment-4461273
-    let maxFeePerGas = transaction.maxFeePerGas |? (baseFeePerGas * 2 + maxPriorityFeePerGas)
-    populated.maxFeePerGas = some(maxFeePerGas)
-
-    populated.gasPrice = none(UInt256)
-
-    trace "EIP-1559 is supported", maxPriorityFeePerGas = maxPriorityFeePerGas, maxFeePerGas = maxFeePerGas
-  else:
-    populated.gasPrice = some(transaction.gasPrice |? (await signer.getGasPrice()))
-    populated.maxFeePerGas = none(UInt256)
-    populated.maxPriorityFeePerGas = none(UInt256)
-    trace "EIP-1559 is not supported", gasPrice = populated.gasPrice
-
-  if transaction.nonce.isNone and transaction.gasLimit.isNone:
-    # when both nonce and gasLimit are not populated, we must ensure getNonce is
-    # followed by an estimateGas so we can determine if there was an error. If
-    # there is an error, the nonce must be decreased to prevent nonce gaps and
-    # stuck transactions
-    populated.nonce = some(await signer.getNonce())
-    try:
-      populated.gasLimit = some(await signer.estimateGas(populated, BlockTag.pending))
-    except EstimateGasError as e:
-      raise e
-    except ProviderError as e:
-      raiseSignerError(e.msg)
-
-  else:
-    if transaction.nonce.isNone:
-      let nonce = await signer.getNonce()
-      populated.nonce = some nonce
-    if transaction.gasLimit.isNone:
-      populated.gasLimit = some(await signer.estimateGas(populated, BlockTag.pending))
-
-  doAssert populated.nonce.isSome, "nonce not populated!"
+  finally:
+    signer.populateLock.release()
 
   return populated
 
 method cancelTransaction*(
   signer: Signer,
   tx: Transaction
-): Future[TransactionResponse] {.base, async: (raises: [SignerError, CancelledError, ProviderError]).} =
+): Future[TransactionResponse] {.async, base.} =
   # cancels a transaction by sending with a 0-valued transaction to ourselves
   # with the failed tx's nonce
 
@@ -187,8 +147,6 @@ method cancelTransaction*(
   without nonce =? tx.nonce:
     raiseSignerError "transaction must have nonce"
 
-  withLock(signer):
-    convertError:
-      var cancelTx = Transaction(to: sender, value: 0.u256, nonce: some nonce)
-      cancelTx = await signer.populateTransaction(cancelTx)
-      return await signer.sendTransaction(cancelTx)
+  var cancelTx = Transaction(to: sender, value: 0.u256, nonce: some nonce)
+  cancelTx = await signer.populateTransaction(cancelTx)
+  return await signer.sendTransaction(cancelTx)

ethers/signers/jsonrpc.nim

@@ -1,3 +0,0 @@
-import ../providers/jsonrpc
-
-export provider, getAddress, signMessage, sendTransaction

ethers/signers/wallet.nim

@@ -1,89 +0,0 @@
-import eth/keys
-import ../basics
-import ../provider
-import ../transaction
-import ../signer
-import ./wallet/error
-import ./wallet/signing
-
-export keys
-export WalletError
-export signing
-
-{.push raises: [].}
-
-var rng {.threadvar.}: ref HmacDrbgContext
-
-proc getRng: ref HmacDrbgContext =
-  if rng.isNil:
-    rng = newRng()
-  rng
-
-type Wallet* = ref object of Signer
-  privateKey*: PrivateKey
-  publicKey*: PublicKey
-  address*: Address
-  provider*: ?Provider
-
-proc new*(_: type Wallet, privateKey: PrivateKey): Wallet =
-  let publicKey = privateKey.toPublicKey()
-  let address = Address(publicKey.toCanonicalAddress())
-  Wallet(privateKey: privateKey, publicKey: publicKey, address: address)
-
-proc new*(_: type Wallet, privateKey: PrivateKey, provider: Provider): Wallet =
-  let wallet = Wallet.new(privateKey)
-  wallet.provider = some provider
-  wallet
-
-proc new*(_: type Wallet, privateKey: string): ?!Wallet =
-  let keyResult = PrivateKey.fromHex(privateKey)
-  if keyResult.isErr:
-    return failure newException(WalletError, "invalid key: " & $keyResult.error)
-  success Wallet.new(keyResult.get())
-
-proc new*(_: type Wallet, privateKey: string, provider: Provider): ?!Wallet =
-  let wallet = ? Wallet.new(privateKey)
-  wallet.provider = some provider
-  success wallet
-
-proc connect*(wallet: Wallet, provider: Provider) =
-  wallet.provider = some provider
-
-proc createRandom*(_: type Wallet): Wallet =
-  result = Wallet()
-  result.privateKey = PrivateKey.random(getRng()[])
-  result.publicKey = result.privateKey.toPublicKey()
-  result.address = Address(result.publicKey.toCanonicalAddress())
-
-proc createRandom*(_: type Wallet, provider: Provider): Wallet =
-  result = Wallet()
-  result.privateKey = PrivateKey.random(getRng()[])
-  result.publicKey = result.privateKey.toPublicKey()
-  result.address = Address(result.publicKey.toCanonicalAddress())
-  result.provider = some provider
-
-method provider*(wallet: Wallet): Provider {.gcsafe, raises: [SignerError].} =
-  without provider =? wallet.provider:
-    raiseWalletError "Wallet has no provider"
-  provider
-
-method getAddress*(
-  wallet: Wallet): Future[Address]
-  {.async: (raises:[ProviderError, SignerError, CancelledError]).} =
-
-  return wallet.address
-
-proc signTransaction*(wallet: Wallet,
-                      transaction: Transaction): Future[seq[byte]] {.async: (raises:[WalletError]).} =
-  if sender =? transaction.sender and sender != wallet.address:
-    raiseWalletError "from address mismatch"
-
-  return wallet.privateKey.sign(transaction)
-
-method sendTransaction*(
-  wallet: Wallet,
-  transaction: Transaction): Future[TransactionResponse]
-  {.async: (raises:[SignerError, ProviderError, CancelledError]).} =
-
-  let signed = await signTransaction(wallet, transaction)
-  return await provider(wallet).sendTransaction(signed)

ethers/signers/wallet/error.nim

@@ -1,15 +0,0 @@
-import ../../signer
-
-type
-  WalletError* = object of SignerError
-
-func raiseWalletError*(message: string) {.raises: [WalletError].}=
-  raise newException(WalletError, message)
-
-template convertError*(body) =
-  try:
-    body
-  except CancelledError as error:
-    raise error
-  except CatchableError as error:
-    raiseWalletError(error.msg)

ethers/testing.nim

@@ -27,7 +27,7 @@ proc reverts*[T](call: Future[T]): Future[bool] {.async.} =
     else:
       discard await call
     return false
-  except ProviderError, SignerError, EstimateGasError:
+  except ProviderError, EstimateGasError:
     return true
 
 proc reverts*[T](call: Future[T], reason: string): Future[bool] {.async.} =
@@ -37,7 +37,7 @@ proc reverts*[T](call: Future[T], reason: string): Future[bool] {.async.} =
     else:
       discard await call
     return false
-  except ProviderError, SignerError, EstimateGasError:
+  except ProviderError, EstimateGasError:
     let e = getCurrentException()
     var passed = reason == (ref EthersError)(e).revertReason
     if not passed and

ethers/transaction.nim

@@ -1,4 +1,3 @@
-import pkg/serde
 import pkg/stew/byteutils
 import ./basics
 
@@ -7,18 +6,18 @@ type
     Legacy = 0,
     AccessList = 1,
     Dynamic = 2
-  Transaction* {.serialize.} = object
-    sender* {.serialize("from").}: ?Address
+  Transaction* = object
+    sender*: ?Address
     to*: Address
     data*: seq[byte]
     value*: UInt256
     nonce*: ?UInt256
     chainId*: ?UInt256
     gasPrice*: ?UInt256
-    maxPriorityFeePerGas*: ?UInt256
-    maxFeePerGas*: ?UInt256
+    maxFee*: ?UInt256
+    maxPriorityFee*: ?UInt256
     gasLimit*: ?UInt256
-    transactionType* {.serialize("type").}: ?TransactionType
+    transactionType*: ?TransactionType
 
 func `$`*(transaction: Transaction): string =
   result = "("

ethers/wallet.nim

@@ -1,3 +1,76 @@
-import ./signers/wallet
+import eth/keys
+import ./basics
+import ./provider
+import ./transaction
+import ./signer
+import ./wallet/error
+import ./wallet/signing
 
-export wallet
+export keys
+export WalletError
+export signing
+
+var rng {.threadvar.}: ref HmacDrbgContext
+
+proc getRng: ref HmacDrbgContext =
+  if rng.isNil:
+    rng = newRng()
+  rng
+
+type Wallet* = ref object of Signer
+  privateKey*: PrivateKey
+  publicKey*: PublicKey
+  address*: Address
+  provider*: ?Provider
+
+proc new*(_: type Wallet, privateKey: PrivateKey): Wallet =
+  let publicKey = privateKey.toPublicKey()
+  let address = Address.init(publicKey.toCanonicalAddress())
+  Wallet(privateKey: privateKey, publicKey: publicKey, address: address)
+proc new*(_: type Wallet, privateKey: PrivateKey, provider: Provider): Wallet =
+  let wallet = Wallet.new(privateKey)
+  wallet.provider = some provider
+  wallet
+proc new*(_: type Wallet, privateKey: string): ?!Wallet =
+  let keyResult = PrivateKey.fromHex(privateKey)
+  if keyResult.isErr:
+    return failure newException(WalletError, "invalid key: " & $keyResult.error)
+  success Wallet.new(keyResult.get())
+proc new*(_: type Wallet, privateKey: string, provider: Provider): ?!Wallet =
+  let wallet = ? Wallet.new(privateKey)
+  wallet.provider = some provider
+  success wallet
+proc connect*(wallet: Wallet, provider: Provider) =
+  wallet.provider = some provider
+proc createRandom*(_: type Wallet): Wallet =
+  result = Wallet()
+  result.privateKey = PrivateKey.random(getRng()[])
+  result.publicKey = result.privateKey.toPublicKey()
+  result.address = Address.init(result.publicKey.toCanonicalAddress())
+proc createRandom*(_: type Wallet, provider: Provider): Wallet =
+  result = Wallet()
+  result.privateKey = PrivateKey.random(getRng()[])
+  result.publicKey = result.privateKey.toPublicKey()
+  result.address = Address.init(result.publicKey.toCanonicalAddress())
+  result.provider = some provider
+
+method provider*(wallet: Wallet): Provider =
+  without provider =? wallet.provider:
+    raiseWalletError "Wallet has no provider"
+  provider
+
+method getAddress(wallet: Wallet): Future[Address] {.async.} =
+  return wallet.address
+
+proc signTransaction*(wallet: Wallet,
+                      transaction: Transaction): Future[seq[byte]] {.async.} =
+  if sender =? transaction.sender and sender != wallet.address:
+    raiseWalletError "from address mismatch"
+
+  return wallet.privateKey.sign(transaction)
+
+method sendTransaction*(wallet: Wallet, transaction: Transaction): Future[TransactionResponse] {.async.} =
+  let signed = await signTransaction(wallet, transaction)
+  if nonce =? transaction.nonce:
+    wallet.updateNonce(nonce)
+  return await provider(wallet).sendTransaction(signed)

ethers/wallet/error.nim

@@ -0,0 +1,7 @@
+import ../basics
+
+type
+  WalletError* = object of EthersError
+
+func raiseWalletError*(message: string) =
+  raise newException(WalletError, message)

ethers/wallet/signing.nim

@@ -1,13 +1,11 @@
 import pkg/eth/keys
 import pkg/eth/rlp
 import pkg/eth/common/transaction as eth
-import pkg/eth/common/transaction_utils
 import pkg/eth/common/eth_hash
-import ../../basics
-import ../../transaction as ethers
-import ../../provider
+import ../basics
+import ../transaction as ethers
+import ../provider
 import ./error
-from pkg/eth/common/eth_types import EthAddress
 
 type
   Transaction = ethers.Transaction
@@ -26,18 +24,17 @@ func toSignableTransaction(transaction: Transaction): SignableTransaction =
     raiseWalletError "missing gas limit"
 
   signable.nonce = nonce.truncate(uint64)
-  signable.chainId = chainId
+  signable.chainId = ChainId(chainId.truncate(uint64))
   signable.gasLimit = GasInt(gasLimit.truncate(uint64))
-
-  signable.to = Opt.some(EthAddress(transaction.to))
+  signable.to = some EthAddress(transaction.to)
   signable.value = transaction.value
   signable.payload = transaction.data
 
-  if maxFeePerGas =? transaction.maxFeePerGas and
-     maxPriorityFeePerGas =? transaction.maxPriorityFeePerGas:
+  if maxFee =? transaction.maxFee and
+     maxPriorityFee =? transaction.maxPriorityFee:
     signable.txType = TxEip1559
-    signable.maxFeePerGas = GasInt(maxFeePerGas.truncate(uint64))
-    signable.maxPriorityFeePerGas = GasInt(maxPriorityFeePerGas.truncate(uint64))
+    signable.maxFee = GasInt(maxFee.truncate(uint64))
+    signable.maxPriorityFee = GasInt(maxPriorityFee.truncate(uint64))
   elif gasPrice =? transaction.gasPrice:
     signable.txType = TxLegacy
     signable.gasPrice = GasInt(gasPrice.truncate(uint64))
@@ -48,7 +45,21 @@ func toSignableTransaction(transaction: Transaction): SignableTransaction =
 
 func sign(key: PrivateKey, transaction: SignableTransaction): seq[byte] =
   var transaction = transaction
-  transaction.signature = transaction.sign(key, true)
+
+  # Temporary V value, used to signal to the hashing function
+  # that we'd like to use an EIP-155 signature
+  transaction.V = int64(uint64(transaction.chainId)) * 2 + 35
+
+  let hash = transaction.txHashNoSignature().data
+  let signature = key.sign(SkMessage(hash)).toRaw()
+
+  transaction.R = UInt256.fromBytesBE(signature[0..<32])
+  transaction.S = UInt256.fromBytesBE(signature[32..<64])
+  transaction.V = int64(signature[64])
+
+  if transaction.txType == TxLegacy:
+    transaction.V += int64(uint64(transaction.chainId)) * 2 + 35
+
   rlp.encode(transaction)
 
 func sign*(key: PrivateKey, transaction: Transaction): seq[byte] =

nim.cfg

@@ -1,4 +1,3 @@
 -d:"chronicles_log_level=INFO"
 -d:"json_rpc_websocket_package=websock"
 --warning[LockLevel]:off
---warning[DotLikeOps]:off

testmodule/config.nims

@@ -3,5 +3,3 @@ when (NimMajor, NimMinor) >= (1, 4):
   switch("hint", "XCannotRaiseY:off")
 when (NimMajor, NimMinor, NimPatch) >= (1, 6, 11):
   switch("warning", "BareExcept:off")
-
---define:"chronicles_enabled:off"

testmodule/hardhat.nim

@@ -1,4 +1,4 @@
-import pkg/serde
+import std/json
 import pkg/ethers/basics
 
 type Deployment* = object

testmodule/helpers.nim

@@ -7,7 +7,7 @@ type
 method doRevert*(
   self: TestHelpers,
   revertReason: string
-): Confirmable {.base, contract.}
+): ?TransactionResponse {.base, contract.}
 
 proc new*(_: type TestHelpers, signer: Signer): TestHelpers =
   let deployment = readDeployment()

testmodule/mocks.nim

@@ -11,15 +11,10 @@ func new*(_: type MockSigner, provider: Provider): MockSigner =
 method provider*(signer: MockSigner): Provider =
   signer.provider
 
-method getAddress*(
-  signer: MockSigner): Future[Address]
-  {.async: (raises:[ProviderError, SignerError, CancelledError]).} =
-
+method getAddress*(signer: MockSigner): Future[Address] {.async.} =
   return signer.address
 
-method sendTransaction*(
-  signer: MockSigner,
-  transaction: Transaction): Future[TransactionResponse]
-  {.async: (raises:[SignerError, ProviderError, CancelledError]).} =
-
+method sendTransaction*(signer: MockSigner,
+                        transaction: Transaction):
+                       Future[TransactionResponse] {.async.} =
   signer.transactions.add(transaction)

testmodule/providers/jsonrpc/rpc_mock.nim

@@ -1,56 +0,0 @@
-import ../../examples
-import ../../../ethers/provider
-import ../../../ethers/providers/jsonrpc/conversions
-
-import std/sequtils
-import pkg/stew/byteutils
-import pkg/json_rpc/rpcserver except `%`, `%*`
-import pkg/json_rpc/errors
-
-type MockRpcHttpServer* = ref object
-  filters*: seq[string]
-  nextGetChangesReturnsError*: bool
-  srv: RpcHttpServer
-
-proc new*(_: type MockRpcHttpServer): MockRpcHttpServer =
-  let srv = newRpcHttpServer(["127.0.0.1:0"])
-  MockRpcHttpServer(filters: @[], srv: srv, nextGetChangesReturnsError: false)
-
-proc invalidateFilter*(server: MockRpcHttpServer, jsonId: JsonNode) =
-  server.filters.keepItIf it != jsonId.getStr
-
-proc start*(server: MockRpcHttpServer) =
-  server.srv.router.rpc("eth_newFilter") do(filter: EventFilter) -> string:
-    let filterId = "0x" & (array[16, byte].example).toHex
-    server.filters.add filterId
-    return filterId
-
-  server.srv.router.rpc("eth_newBlockFilter") do() -> string:
-    let filterId = "0x" & (array[16, byte].example).toHex
-    server.filters.add filterId
-    return filterId
-
-  server.srv.router.rpc("eth_getFilterChanges") do(id: string) -> seq[string]:
-    if server.nextGetChangesReturnsError:
-          raise (ref ApplicationError)(code: -32000, msg: "unknown error")
-
-    if id notin server.filters:
-      raise (ref ApplicationError)(code: -32000, msg: "filter not found")
-
-    return @[]
-
-  server.srv.router.rpc("eth_uninstallFilter") do(id: string) -> bool:
-    if id notin server.filters:
-      raise (ref ApplicationError)(code: -32000, msg: "filter not found")
-
-    server.invalidateFilter(%id)
-    return true
-
-  server.srv.start()
-
-proc stop*(server: MockRpcHttpServer) {.async.} =
-  await server.srv.stop()
-  await server.srv.closeWait()
-
-proc localAddress*(server: MockRpcHttpServer): seq[TransportAddress] =
-  return server.srv.localAddress()

testmodule/providers/jsonrpc/testConversions.nim

@@ -2,9 +2,6 @@ import std/strutils
 import std/unittest
 import pkg/ethers/provider
 import pkg/ethers/providers/jsonrpc/conversions
-import pkg/questionable
-import pkg/questionable/results
-import pkg/serde
 import pkg/stew/byteutils
 
 func flatten(s: string): string =
@@ -20,13 +17,14 @@ suite "JSON Conversions":
       "timestamp":"0x6285c293"
     }
 
-    let blk1 = !Block.fromJson(json)
-    check blk1.number.isNone
+    var blk = Block.fromJson(json)
+    check blk.number.isNone
 
     json["number"] = newJString("")
 
-    let blk2 = !Block.fromJson(json)
-    check blk2.number.isNone
+    blk = Block.fromJson(json)
+    check blk.number.isSome
+    check blk.number.get.isZero
 
   test "missing block hash in Block isNone":
 
@@ -39,8 +37,7 @@ suite "JSON Conversions":
       }
     }
 
-    without blk =? Block.fromJson(blkJson["result"]):
-      unittest.fail
+    var blk = Block.fromJson(blkJson["result"])
     check blk.hash.isNone
 
   test "missing block number in TransactionReceipt isNone":
@@ -70,14 +67,13 @@ suite "JSON Conversions":
       "type": "0x0"
     }
 
-    without receipt1 =? TransactionReceipt.fromJson(json):
-      unittest.fail
-    check receipt1.blockNumber.isNone
+    var receipt = TransactionReceipt.fromJson(json)
+    check receipt.blockNumber.isNone
 
     json["blockNumber"] = newJString("")
-    without receipt2 =? TransactionReceipt.fromJson(json):
-      unittest.fail
-    check receipt2.blockNumber.isNone
+    receipt = TransactionReceipt.fromJson(json)
+    check receipt.blockNumber.isSome
+    check receipt.blockNumber.get.isZero
 
   test "missing block hash in TransactionReceipt isNone":
     let json = %*{
@@ -106,10 +102,33 @@ suite "JSON Conversions":
       "type": "0x0"
     }
 
-    without receipt =? TransactionReceipt.fromJson(json):
-      unittest.fail
+    let receipt = TransactionReceipt.fromJson(json)
     check receipt.blockHash.isNone
 
+  test "newHeads subcription raises exception when deserializing to Log":
+    let json = """{
+      "parentHash":"0xd68d4d0f29307df51e1284fc8a13595ae700ef0f1128830a69e6854381363d42",
+      "sha3Uncles":"0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+      "miner":"0x0000000000000000000000000000000000000000",
+      "stateRoot":"0x1f6f2d05de35bbfd50213be96ddf960d62b978b472c55d6ac223cd648cbbbbb0",
+      "transactionsRoot":"0xb9bb8a26abe091bb628ab2b6585c5af151aeb3984f4ba47a3c65d438283e069d",
+      "receiptsRoot":"0x33f229b7133e1ba3fb524b8af22d8184ca10b2da5bb170092a219c61ca023c1d",
+      "logsBloom":"0x00000000000000000000000000000000000000000020000000000002000000000000000000000000000000000000000000000000000008080000100200200000000000000000000000000008000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000010000040000000000100000000000800000000000000000000000000000000020000000000020000000000000000000000000000040000008000000000000000000020000000000002000000000000000000000000000000000000000000000000000001000010000000000000000020002000000020000000000000008002000000000000",
+      "difficulty":"0x2",
+      "number":"0x21d",
+      "gasLimit":"0x1c1b59a7",
+      "gasUsed":"0xda41b",
+      "timestamp":"0x6509410e",
+      "extraData":"0xd883010b05846765746888676f312e32302e32856c696e7578000000000000007102a27d75709b90ca9eb23cdaaccf4fc2d571d710f3bc5a7dc874f43af116a93ff832576a53c16f0d0aa1cd9e9a1dc0a60126c4d420f72b0866fc96ba6664f601",
+      "mixHash":"0x0000000000000000000000000000000000000000000000000000000000000000",
+      "nonce":"0x0000000000000000",
+      "baseFeePerGas":"0x7",
+      "withdrawalsRoot":null,
+      "hash":"0x64066c7150c660e5357c4b6b02d836c10353dfa8edb32c805fca9367fd29c6e7"
+    }"""
+    expect ValueError:
+      discard Log.fromJson(parseJson(json))
+
   test "correctly deserializes PastTransaction":
     let json = %*{
       "blockHash":"0x595bffbe897e025ea2df3213c4cc52c3f3d69bc04b49011d558f1b0e70038922",
@@ -130,9 +149,8 @@ suite "JSON Conversions":
       "s":"0x33aa50bc8bd719b6b17ad0bf52006bf8943999198f2bf731eb33c118091000f2"
     }
 
-    without tx =? PastTransaction.fromJson(json):
-      unittest.fail
-    check tx.blockHash == BlockHash.fromHex("0x595bffbe897e025ea2df3213c4cc52c3f3d69bc04b49011d558f1b0e70038922")
+    let tx = PastTransaction.fromJson(json)
+    check tx.blockHash == BlockHash(array[32, byte].fromHex("0x595bffbe897e025ea2df3213c4cc52c3f3d69bc04b49011d558f1b0e70038922"))
     check tx.blockNumber == 0x22e.u256
     check tx.sender == Address.init("0xe00b677c29ff8d8fe6068530e2bc36158c54dd34").get
     check tx.gas == 0x4d4bb.u256
@@ -151,7 +169,7 @@ suite "JSON Conversions":
 
   test "PastTransaction serializes correctly":
     let tx = PastTransaction(
-      blockHash: BlockHash.fromHex("0x595bffbe897e025ea2df3213c4cc52c3f3d69bc04b49011d558f1b0e70038922"),
+      blockHash: BlockHash(array[32, byte].fromHex("0x595bffbe897e025ea2df3213c4cc52c3f3d69bc04b49011d558f1b0e70038922")),
       blockNumber: 0x22e.u256,
       sender: Address.init("0xe00b677c29ff8d8fe6068530e2bc36158c54dd34").get,
       gas: 0x4d4bb.u256,
@@ -180,12 +198,12 @@ suite "JSON Conversions":
         "nonce":"0x3",
         "to":"0x92f09aa59dccb892a9f5406ddd9c0b98f02ea57e",
         "transactionIndex":"0x3",
-        "type":"0x0",
-        "chainId":"0xc0de4",
         "value":"0x0",
         "v":"0x181bec",
         "r":"0x57ba18460934526333b80b0fea08737c363f3cd5fbec4a25a8a25e3e8acb362a",
-        "s":"0x33aa50bc8bd719b6b17ad0bf52006bf8943999198f2bf731eb33c118091000f2"
+        "s":"0x33aa50bc8bd719b6b17ad0bf52006bf8943999198f2bf731eb33c118091000f2",
+        "type":"0x0",
+        "chainId":"0xc0de4"
       }""".flatten
     check $(%tx) == expected
 
@@ -209,46 +227,13 @@ suite "JSON Conversions":
       "s":"0x33aa50bc8bd719b6b17ad0bf52006bf8943999198f2bf731eb33c118091000f2"
     }
 
-    without past =? PastTransaction.fromJson(json):
-      unittest.fail
+    let past = PastTransaction.fromJson(json)
     check %past.toTransaction == %*{
       "to": !Address.init("0x92f09aa59dccb892a9f5406ddd9c0b98f02ea57e"),
       "data": hexToSeqByte("0x6368a471d26ff5c7f835c1a8203235e88846ce1a196d6e79df0eaedd1b8ed3deec2ae5c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000012a00000000000000000000000000000000000000000000000000000000000000"),
-      "value": "0x0",
       "from": !Address.init("0xe00b677c29ff8d8fe6068530e2bc36158c54dd34"),
       "nonce": 0x3.u256,
       "chainId": 0xc0de4.u256,
       "gasPrice": 0x3b9aca07.u256,
       "gas": 0x52277.u256
     }
-
-  test "correctly deserializes BlockTag":
-    check !BlockTag.fromJson(newJString("earliest")) == BlockTag.earliest
-    check !BlockTag.fromJson(newJString("latest")) == BlockTag.latest
-    check !BlockTag.fromJson(newJString("pending")) == BlockTag.pending
-    check !BlockTag.fromJson(newJString("0x1")) == BlockTag.init(1.u256)
-
-  test "fails to deserialize BlockTag from an empty string":
-    let res = BlockTag.fromJson(newJString(""))
-    check res.error of SerializationError
-    check res.error.msg == "Failed to convert '\"\"' to BlockTag: must be one of 'earliest', 'latest', 'pending'"
-
-  test "correctly deserializes TransactionType":
-    check !TransactionType.fromJson(newJString("0x0")) == TransactionType.Legacy
-    check !TransactionType.fromJson(newJString("0x1")) == TransactionType.AccessList
-    check !TransactionType.fromJson(newJString("0x2")) == TransactionType.Dynamic
-
-  test "correctly serializes TransactionType":
-    check TransactionType.Legacy.toJson == "\"0x0\""
-    check TransactionType.AccessList.toJson == "\"0x1\""
-    check TransactionType.Dynamic.toJson == "\"0x2\""
-
-  test "correctly deserializes TransactionStatus":
-    check !TransactionStatus.fromJson(newJString("0x0")) == TransactionStatus.Failure
-    check !TransactionStatus.fromJson(newJString("0x1")) == TransactionStatus.Success
-    check !TransactionStatus.fromJson(newJString("0x2")) == TransactionStatus.Invalid
-
-  test "correctly serializes TransactionStatus":
-    check TransactionStatus.Failure.toJson == "\"0x0\""
-    check TransactionStatus.Success.toJson == "\"0x1\""
-    check TransactionStatus.Invalid.toJson == "\"0x2\""

testmodule/providers/jsonrpc/testErrors.nim

@@ -1,27 +0,0 @@
-import std/unittest
-import pkg/serde
-import pkg/questionable
-import pkg/ethers/providers/jsonrpc/errors
-
-suite "JSON RPC errors":
-
-  test "converts JSON RPC error to Nim error":
-    let error = %*{ "message": "some error" }
-    check JsonRpcProviderError.new(error).msg == "some error"
-
-  test "converts error data to bytes":
-    let error = %*{
-      "message": "VM Exception: reverted with 'some error'",
-      "data": "0xabcd"
-    }
-    check JsonRpcProviderError.new(error).data == some @[0xab'u8, 0xcd'u8]
-
-  test "converts nested error data to bytes":
-    let error = %*{
-      "message": "VM Exception: reverted with 'some error'",
-      "data": {
-        "message": "VM Exception: reverted with 'some error'",
-        "data": "0xabcd"
-      }
-    }
-    check JsonRpcProviderError.new(error).data == some @[0xab'u8, 0xcd'u8]

testmodule/providers/jsonrpc/testJsonRpcProvider.nim

@@ -1,5 +1,5 @@
-import std/os
-import pkg/asynctest/chronos/unittest
+import std/json
+import pkg/asynctest
 import pkg/chronos
 import pkg/ethers
 import pkg/ethers/providers/jsonrpc/conversions
@@ -7,8 +7,7 @@ import pkg/stew/byteutils
 import ../../examples
 import ../../miner
 
-let providerUrl = getEnv("ETHERS_TEST_PROVIDER", "localhost:8545")
-for url in ["ws://" & providerUrl, "http://"  & providerUrl]:
+for url in ["ws://localhost:8545", "http://localhost:8545"]:
 
   suite "JsonRpcProvider (" & url & ")":
 
@@ -30,7 +29,7 @@ for url in ["ws://" & providerUrl, "http://"  & providerUrl]:
 
     test "sends raw messages to the provider":
       let response = await provider.send("evm_mine")
-      check response == %"0"
+      check response == %"0x0"
 
     test "returns block number":
       let blocknumber1 = await provider.getBlockNumber()
@@ -49,7 +48,7 @@ for url in ["ws://" & providerUrl, "http://"  & providerUrl]:
       let oldBlock = !await provider.getBlock(BlockTag.latest)
       discard await provider.send("evm_mine")
       var newBlock: Block
-      let blockHandler = proc(blck: ?!Block) {.raises:[].}= newBlock = blck.value
+      let blockHandler = proc(blck: Block) = newBlock = blck
       let subscription = await provider.subscribe(blockHandler)
       discard await provider.send("evm_mine")
       check eventually newBlock.number.isSome
@@ -68,13 +67,13 @@ for url in ["ws://" & providerUrl, "http://"  & providerUrl]:
       check UInt256.fromHex("0x" & txResp.hash.toHex) > 0
 
     test "can wait for a transaction to be confirmed":
-      for confirmations in 1..3:
+      for confirmations in 0..3:
         let signer = provider.getSigner()
         let transaction = Transaction.example
         let populated = await signer.populateTransaction(transaction)
         let confirming = signer.sendTransaction(populated).confirm(confirmations)
         await sleepAsync(100.millis) # wait for tx to be mined
-        await provider.mineBlocks(confirmations)
+        await provider.mineBlocks(confirmations - 1)
         let receipt = await confirming
         check receipt.blockNumber.isSome
 
@@ -82,7 +81,6 @@ for url in ["ws://" & providerUrl, "http://"  & providerUrl]:
       let hash = TransactionHash.example
       let tx = TransactionResponse(provider: provider, hash: hash)
       let confirming = tx.confirm(confirmations = 2, timeout = 5)
-      await sleepAsync(100.millis) # wait for confirm to subscribe to new blocks
       await provider.mineBlocks(5)
       expect EthersError:
         discard await confirming
@@ -98,7 +96,7 @@ for url in ["ws://" & providerUrl, "http://"  & providerUrl]:
       expect JsonRpcProviderError:
         discard await provider.getBlock(BlockTag.latest)
       expect JsonRpcProviderError:
-        discard await provider.subscribe(proc(_: ?!Block) = discard)
+        discard await provider.subscribe(proc(_: Block) = discard)
       expect JsonRpcProviderError:
         discard await provider.getSigner().sendTransaction(Transaction.example)
 

testmodule/providers/jsonrpc/testJsonRpcSigner.nim

@@ -1,5 +1,4 @@
-import std/os
-import pkg/asynctest/chronos/unittest
+import pkg/asynctest
 import pkg/ethers
 import pkg/stew/byteutils
 import ../../examples
@@ -8,10 +7,9 @@ suite "JsonRpcSigner":
 
   var provider: JsonRpcProvider
   var accounts: seq[Address]
-  let providerUrl = getEnv("ETHERS_TEST_PROVIDER", "localhost:8545")
 
   setup:
-    provider = JsonRpcProvider.new("http://" & providerUrl)
+    provider = JsonRpcProvider.new()
     accounts = await provider.listAccounts()
 
   teardown:
@@ -55,27 +53,20 @@ suite "JsonRpcSigner":
     let transaction = Transaction.example
     let populated = await signer.populateTransaction(transaction)
     check !populated.sender == await signer.getAddress()
+    check !populated.gasPrice == await signer.getGasPrice()
     check !populated.nonce == await signer.getTransactionCount(BlockTag.pending)
     check !populated.gasLimit == await signer.estimateGas(transaction)
     check !populated.chainId == await signer.getChainId()
 
-    let blk = !(await signer.provider.getBlock(BlockTag.latest))
-    check !populated.maxPriorityFeePerGas == await signer.getMaxPriorityFeePerGas()
-    check !populated.maxFeePerGas == !blk.baseFeePerGas * 2.u256 + !populated.maxPriorityFeePerGas
-
   test "populate does not overwrite existing fields":
     let signer = provider.getSigner()
     var transaction = Transaction.example
     transaction.sender = some await signer.getAddress()
     transaction.nonce = some UInt256.example
     transaction.chainId = some await signer.getChainId()
-    transaction.maxPriorityFeePerGas = some UInt256.example
+    transaction.gasPrice = some UInt256.example
     transaction.gasLimit = some UInt256.example
     let populated = await signer.populateTransaction(transaction)
-
-    let blk = !(await signer.provider.getBlock(BlockTag.latest))
-    transaction.maxFeePerGas = some(!blk.baseFeePerGas * 2.u256 + !populated.maxPriorityFeePerGas)
-    
     check populated == transaction
 
   test "populate fails when sender does not match signer address":
@@ -91,3 +82,24 @@ suite "JsonRpcSigner":
     transaction.chainId = 0xdeadbeef.u256.some
     expect SignerError:
       discard await signer.populateTransaction(transaction)
+
+  test "concurrent populate calls increment nonce":
+    let signer = provider.getSigner()
+    let count = await signer.getTransactionCount(BlockTag.pending)
+    var transaction1 = Transaction.example
+    var transaction2 = Transaction.example
+    var transaction3 = Transaction.example
+
+    let populated = await allFinished(
+      signer.populateTransaction(transaction1),
+      signer.populateTransaction(transaction2),
+      signer.populateTransaction(transaction3)
+    )
+
+    transaction1 = await populated[0]
+    transaction2 = await populated[1]
+    transaction3 = await populated[2]
+
+    check !transaction1.nonce == count
+    check !transaction2.nonce == count + 1.u256
+    check !transaction3.nonce == count + 2.u256

testmodule/providers/jsonrpc/testJsonRpcSubscriptions.nim

@@ -1,15 +1,9 @@
-import std/os
-import std/importutils
-import pkg/asynctest/chronos/unittest
-import pkg/serde
+import std/json
+import pkg/asynctest
 import pkg/json_rpc/rpcclient
-import pkg/json_rpc/rpcserver
 import ethers/provider
 import ethers/providers/jsonrpc/subscriptions
 
-import ../../examples
-import ./rpc_mock
-
 suite "JsonRpcSubscriptions":
 
   test "can be instantiated with an http client":
@@ -26,8 +20,8 @@ template subscriptionTests(subscriptions, client) =
 
   test "subscribes to new blocks":
     var latestBlock: Block
-    proc callback(blck: ?!Block) =
-      latestBlock = blck.value
+    proc callback(blck: Block) =
+      latestBlock = blck
     let subscription = await subscriptions.subscribeBlocks(callback)
     discard await client.call("evm_mine", newJArray())
     check eventually latestBlock.number.isSome
@@ -37,9 +31,8 @@ template subscriptionTests(subscriptions, client) =
 
   test "stops listening to new blocks when unsubscribed":
     var count = 0
-    proc callback(blck: ?!Block) =
-      if blck.isOk:
-        inc count
+    proc callback(blck: Block) =
+      inc count
     let subscription = await subscriptions.subscribeBlocks(callback)
     discard await client.call("evm_mine", newJArray())
     check eventually count > 0
@@ -49,20 +42,10 @@ template subscriptionTests(subscriptions, client) =
     await sleepAsync(100.millis)
     check count == 0
 
-  test "unsubscribing from a non-existent subscription does not do any harm":
-    await subscriptions.unsubscribe(newJInt(0))
-
-  test "duplicate unsubscribe is harmless":
-    proc callback(blck: ?!Block) = discard
-    let subscription = await subscriptions.subscribeBlocks(callback)
-    await subscriptions.unsubscribe(subscription)
-    await subscriptions.unsubscribe(subscription)
-
   test "stops listening to new blocks when provider is closed":
     var count = 0
-    proc callback(blck: ?!Block) =
-      if blck.isOk:
-        inc count
+    proc callback(blck: Block) =
+      inc count
     discard await subscriptions.subscribeBlocks(callback)
     discard await client.call("evm_mine", newJArray())
     check eventually count > 0
@@ -79,9 +62,8 @@ suite "Web socket subscriptions":
 
   setup:
     client = newRpcWebSocketClient()
-    await client.connect("ws://"  & getEnv("ETHERS_TEST_PROVIDER", "localhost:8545"))
+    await client.connect("ws://localhost:8545")
     subscriptions = JsonRpcSubscriptions.new(client)
-    subscriptions.start()
 
   teardown:
     await subscriptions.close()
@@ -96,123 +78,12 @@ suite "HTTP polling subscriptions":
 
   setup:
     client = newRpcHttpClient()
-    await client.connect("http://" & getEnv("ETHERS_TEST_PROVIDER", "localhost:8545"))
+    await client.connect("http://localhost:8545")
     subscriptions = JsonRpcSubscriptions.new(client,
                                              pollingInterval = 100.millis)
-    subscriptions.start()
 
   teardown:
     await subscriptions.close()
     await client.close()
 
   subscriptionTests(subscriptions, client)
-
-suite "HTTP polling subscriptions - mock tests":
-
-  var subscriptions: PollingSubscriptions
-  var client: RpcHttpClient
-  var mockServer: MockRpcHttpServer
-
-  privateAccess(PollingSubscriptions)
-  privateAccess(JsonRpcSubscriptions)
-
-  proc startServer() {.async.} =
-    mockServer = MockRpcHttpServer.new()
-    mockServer.start()
-    await client.connect("http://" & $mockServer.localAddress()[0])
-
-  proc stopServer() {.async.} =
-    await mockServer.stop()
-
-  setup:
-    client = newRpcHttpClient()
-    await startServer()
-
-    subscriptions = PollingSubscriptions(
-                      JsonRpcSubscriptions.new(
-                        client,
-                        pollingInterval = 1.millis))
-    subscriptions.start()
-
-  teardown:
-    await subscriptions.close()
-    await client.close()
-    await mockServer.stop()
-
-  test "filter not found error recreates log filter":
-    let filter = EventFilter(address: Address.example, topics: @[array[32, byte].example])
-    let emptyHandler = proc(log: ?!Log) = discard
-
-    check subscriptions.logFilters.len == 0
-    check subscriptions.subscriptionMapping.len == 0
-
-    let id = await subscriptions.subscribeLogs(filter, emptyHandler)
-
-    check subscriptions.logFilters[id] == filter
-    check subscriptions.subscriptionMapping[id] == id
-    check subscriptions.logFilters.len == 1
-    check subscriptions.subscriptionMapping.len == 1
-
-    mockServer.invalidateFilter(id)
-
-    check eventually subscriptions.subscriptionMapping[id] != id
-
-  test "recreated log filter can be still unsubscribed using the original id":
-    let filter = EventFilter(address: Address.example, topics: @[array[32, byte].example])
-    let emptyHandler = proc(log: ?!Log) = discard
-    let id = await subscriptions.subscribeLogs(filter, emptyHandler)
-    mockServer.invalidateFilter(id)
-    check eventually subscriptions.subscriptionMapping[id] != id
-
-    await subscriptions.unsubscribe(id)
-
-    check not subscriptions.logFilters.hasKey id
-    check not subscriptions.subscriptionMapping.hasKey id
-
-  test "filter not found error recreates block filter":
-    let emptyHandler = proc(blck: ?!Block) = discard
-
-    check subscriptions.subscriptionMapping.len == 0
-    let id = await subscriptions.subscribeBlocks(emptyHandler)
-    check subscriptions.subscriptionMapping[id] == id
-
-    mockServer.invalidateFilter(id)
-
-    check eventually subscriptions.subscriptionMapping[id] != id
-
-  test "recreated block filter can be still unsubscribed using the original id":
-    let emptyHandler = proc(blck: ?!Block) = discard
-    let id = await subscriptions.subscribeBlocks(emptyHandler)
-    mockServer.invalidateFilter(id)
-    check eventually subscriptions.subscriptionMapping[id] != id
-
-    await subscriptions.unsubscribe(id)
-
-    check not subscriptions.subscriptionMapping.hasKey id
-
-  test "polling continues with new filter after temporary error":
-    let filter = EventFilter(address: Address.example, topics: @[array[32, byte].example])
-    let emptyHandler = proc(log: ?!Log) = discard
-
-    let id = await subscriptions.subscribeLogs(filter, emptyHandler)
-
-    await stopServer()
-    mockServer.invalidateFilter(id)
-    await sleepAsync(50.milliseconds)
-    await startServer()
-
-    check eventually subscriptions.subscriptionMapping[id] != id
-
-  test "calls callback with failed result on error":
-    let filter = EventFilter(address: Address.example, topics: @[array[32, byte].example])
-    var failedResultReceived = false
-
-    proc handler(log: ?!Log) =
-      if log.isErr:
-        failedResultReceived = true
-
-    let id = await subscriptions.subscribeLogs(filter, handler)
-
-    await sleepAsync(50.milliseconds)
-    mockServer.nextGetChangesReturnsError = true
-    check eventually failedResultReceived

testmodule/providers/jsonrpc/testWsResubscription.nim

@@ -1,56 +0,0 @@
-import std/os
-import std/importutils
-import pkg/asynctest/chronos/unittest
-import pkg/json_rpc/rpcclient
-import ethers/provider
-import ethers/providers/jsonrpc/subscriptions
-
-import ../../examples
-
-suite "Websocket re-subscriptions":
-  privateAccess(JsonRpcSubscriptions)
-
-  var subscriptions: JsonRpcSubscriptions
-  var client: RpcWebSocketClient
-  var resubscribeInterval: int
-
-  setup:
-    resubscribeInterval = 3
-    client = newRpcWebSocketClient()
-    await client.connect("ws://"  & getEnv("ETHERS_TEST_PROVIDER", "localhost:8545"))
-    subscriptions = JsonRpcSubscriptions.new(client, resubscribeInterval = resubscribeInterval)
-    subscriptions.start()
-
-  teardown:
-    await subscriptions.close()
-    await client.close()
-
-  test "unsubscribing from a log filter while subscriptions are being resubscribed does not cause a concurrency error":
-    let filter = EventFilter(address: Address.example, topics: @[array[32, byte].example])
-    let emptyHandler = proc(log: ?!Log) = discard
-
-    for i in 1..10:
-      discard await subscriptions.subscribeLogs(filter, emptyHandler)
-
-    # Wait until the re-subscription starts
-    await sleepAsync(resubscribeInterval.seconds)
-
-    # Attempt to modify callbacks while its being iterated
-    discard await subscriptions.subscribeLogs(filter, emptyHandler)
-
-  test "resubscribe events take effect with new subscription IDs in the log filters":
-    let filter = EventFilter(address: Address.example, topics: @[array[32, byte].example])
-    let emptyHandler = proc(log: ?!Log) = discard
-    let id = await subscriptions.subscribeLogs(filter, emptyHandler)
-
-    check id in subscriptions.logFilters
-    check subscriptions.logFilters.len == 1
-
-    # Make sure the subscription is done
-    await sleepAsync((resubscribeInterval + 1).seconds)
-
-    # The previous subscription should not be in the log filters
-    check id notin subscriptions.logFilters
-
-    # There is still one subscription which is the new one
-    check subscriptions.logFilters.len == 1

testmodule/providers/testJsonRpc.nim

@@ -1,8 +1,6 @@
 import ./jsonrpc/testJsonRpcProvider
 import ./jsonrpc/testJsonRpcSigner
 import ./jsonrpc/testJsonRpcSubscriptions
-import ./jsonrpc/testWsResubscription
 import ./jsonrpc/testConversions
-import ./jsonrpc/testErrors
 
 {.warning[UnusedImport]:off.}

testmodule/test.nim

@@ -6,9 +6,5 @@ import ./testEvents
 import ./testWallet
 import ./testTesting
 import ./testErc20
-import ./testGasEstimation
-import ./testErrorDecoding
-import ./testCustomErrors
-import ./testBlockTag
 
 {.warning[UnusedImport]:off.}

testmodule/test.nimble

@@ -3,7 +3,8 @@ author = "Nim Ethers Authors"
 description = "Tests for Nim Ethers library"
 license = "MIT"
 
-requires "asynctest >= 0.5.4 & < 0.6.0"
+requires "asynctest >= 0.4.0 & < 0.5.0"
+requires "questionable >= 0.10.3 & < 0.11.0"
 
 task test, "Run the test suite":
   exec "nimble install -d -y"

testmodule/testBlockTag.nim

@@ -1,56 +0,0 @@
-import std/unittest
-import std/strformat
-
-import pkg/stint
-import pkg/questionable
-
-import ethers/blocktag
-
-
-type
-  PredefinedTags = enum earliest, latest, pending
-
-suite "BlockTag":
-  for predefinedTag in PredefinedTags:
-    test fmt"can be created with predefined special type: {predefinedTag}":
-      var blockTag: BlockTag
-      case predefinedTag:
-      of earliest: blockTag = BlockTag.earliest
-      of latest: blockTag = BlockTag.latest
-      of pending: blockTag = BlockTag.pending
-      check $blockTag == $predefinedTag
-    
-  test "can be created with a number":
-    let blockTag = BlockTag.init(42.u256)
-    check blockTag.number == 42.u256.some
-
-  test "can be converted to string in hex format for BlockTags with number":
-    let blockTag = BlockTag.init(42.u256)
-    check $blockTag == "0x2a"
-
-  test "can be compared for equality when BlockTag with number":
-    let blockTag1 = BlockTag.init(42.u256)
-    let blockTag2 = BlockTag.init(42.u256)
-    let blockTag3 = BlockTag.init(43.u256)
-    check blockTag1 == blockTag2
-    check blockTag1 != blockTag3
-  
-  for predefinedTag in [BlockTag.earliest, BlockTag.latest, BlockTag.pending]:
-    test fmt"can be compared for equality when predefined tag: {predefinedTag}":
-      case $predefinedTag:
-      of "earliest":
-        check predefinedTag == BlockTag.earliest
-        check predefinedTag != BlockTag.latest
-        check predefinedTag != BlockTag.pending
-      of "latest":
-        check predefinedTag != BlockTag.earliest
-        check predefinedTag == BlockTag.latest
-        check predefinedTag != BlockTag.pending
-      of "pending":
-        check predefinedTag != BlockTag.earliest
-        check predefinedTag != BlockTag.latest
-        check predefinedTag == BlockTag.pending
-  
-  for predefinedTag in [BlockTag.earliest, BlockTag.latest, BlockTag.pending]:
-    test fmt"number accessor returns None for BlockTags with string: {predefinedTag}":
-      check predefinedTag.number == UInt256.none

testmodule/testContracts.nim

@@ -1,7 +1,6 @@
-import pkg/serde
-import std/os
+import std/json
 import std/options
-import pkg/asynctest/chronos/unittest
+import pkg/asynctest
 import pkg/questionable
 import pkg/stint
 import pkg/ethers
@@ -14,11 +13,10 @@ import ./mocks
 type
   TestToken = ref object of Erc20Token
 
-method mint(token: TestToken, holder: Address, amount: UInt256): Confirmable {.base, contract.}
+method mint(token: TestToken, holder: Address, amount: UInt256): ?TransactionResponse {.base, contract.}
 method myBalance(token: TestToken): UInt256 {.base, contract, view.}
 
-let providerUrl = getEnv("ETHERS_TEST_PROVIDER", "localhost:8545")
-for url in ["ws://"  & providerUrl, "http://"  & providerUrl]:
+for url in ["ws://localhost:8545", "http://localhost:8545"]:
 
   suite "Contracts (" & url & ")":
 
@@ -64,7 +62,7 @@ for url in ["ws://"  & providerUrl, "http://"  & providerUrl]:
     test "can call constant functions without a return type":
       token = TestToken.new(token.address, provider.getSigner())
       proc mint(token: TestToken, holder: Address, amount: UInt256) {.contract, view.}
-      await token.mint(accounts[1], 100.u256)
+      await mint(token, accounts[1], 100.u256)
       check (await balanceOf(token, accounts[1])) == 0.u256
 
     test "can call non-constant functions without a return type":
@@ -73,14 +71,24 @@ for url in ["ws://"  & providerUrl, "http://"  & providerUrl]:
       await token.mint(accounts[1], 100.u256)
       check (await balanceOf(token, accounts[1])) == 100.u256
 
+    test "can call non-constant functions with a ?TransactionResponse return type":
+      token = TestToken.new(token.address, provider.getSigner())
+      proc mint(token: TestToken,
+                holder: Address,
+                amount: UInt256): ?TransactionResponse {.contract.}
+      let txResp = await token.mint(accounts[1], 100.u256)
+      check txResp is (?TransactionResponse)
+      check txResp.isSome
+
     test "can call non-constant functions with a Confirmable return type":
+
       token = TestToken.new(token.address, provider.getSigner())
       proc mint(token: TestToken,
                 holder: Address,
                 amount: UInt256): Confirmable {.contract.}
-      let confirmable = await token.mint(accounts[1], 100.u256)
-      check confirmable is Confirmable
-      check confirmable.response.isSome
+      let txResp = await token.mint(accounts[1], 100.u256)
+      check txResp is Confirmable
+      check txResp.isSome
 
     test "fails to compile when function has an implementation":
       let works = compiles:
@@ -107,17 +115,17 @@ for url in ["ws://"  & providerUrl, "http://"  & providerUrl]:
       check (await token.connect(provider).balanceOf(accounts[1])) == 25.u256
       check (await token.connect(provider).balanceOf(accounts[2])) == 25.u256
 
-    test "takes custom values for nonce, gasprice and maxPriorityFeePerGas":
+    test "takes custom values for nonce, gasprice and gaslimit":
       let overrides = TransactionOverrides(
         nonce: some 100.u256,
-        maxPriorityFeePerGas: some 200.u256,
+        gasPrice: some 200.u256,
         gasLimit: some 300.u256
       )
       let signer = MockSigner.new(provider)
       discard await token.connect(signer).mint(accounts[0], 42.u256, overrides)
       check signer.transactions.len == 1
       check signer.transactions[0].nonce == overrides.nonce
-      check signer.transactions[0].maxPriorityFeePerGas == overrides.maxPriorityFeePerGas
+      check signer.transactions[0].gasPrice == overrides.gasPrice
       check signer.transactions[0].gasLimit == overrides.gasLimit
 
     test "can call functions for different block heights":
@@ -132,35 +140,10 @@ for url in ["ws://"  & providerUrl, "http://"  & providerUrl]:
       check (await token.balanceOf(accounts[0], beforeMint)) == 0
       check (await token.balanceOf(accounts[0], afterMint)) == 100
 
-    test "can simulate transactions for different block heights":
-      let block1 = await provider.getBlockNumber()
-      let signer = provider.getSigner(accounts[0])
-      discard await token.connect(signer).mint(accounts[0], 100.u256)
-      let block2 = await provider.getBlockNumber()
-
-      let beforeMint = CallOverrides(blockTag: some BlockTag.init(block1))
-      let afterMint = CallOverrides(blockTag: some BlockTag.init(block2))
-
-      expect ProviderError:
-        discard await token.transfer(accounts[1], 50.u256, beforeMint)
-      discard await token.transfer(accounts[1], 50.u256, afterMint)
-
-    test "can estimate gas of a function call":
-      proc mint(token: TestToken, holder: Address, amount: UInt256) {.contract.}
-      let estimate = await token.estimateGas.mint(accounts[1], 100.u256)
-      let correctGas = TransactionOverrides(gasLimit: some estimate)
-      await token.mint(accounts[1], 100.u256, correctGas)
-      let invalidGas = TransactionOverrides(gasLimit: some (estimate - 1))
-      expect ProviderError:
-        await token.mint(accounts[1], 100.u256, invalidGas)
-
     test "receives events when subscribed":
       var transfers: seq[Transfer]
 
-      proc handleTransfer(transferRes: ?!Transfer) =
-        without transfer =? transferRes, error:
-          echo error.msg
-
+      proc handleTransfer(transfer: Transfer) =
         transfers.add(transfer)
 
       let signer0 = provider.getSigner(accounts[0])
@@ -182,9 +165,8 @@ for url in ["ws://"  & providerUrl, "http://"  & providerUrl]:
     test "stops receiving events when unsubscribed":
       var transfers: seq[Transfer]
 
-      proc handleTransfer(transferRes: ?!Transfer) =
-        if transfer =? transferRes:
-          transfers.add(transfer)
+      proc handleTransfer(transfer: Transfer) =
+        transfers.add(transfer)
 
       let signer0 = provider.getSigner(accounts[0])
 
@@ -284,44 +266,3 @@ for url in ["ws://"  & providerUrl, "http://"  & providerUrl]:
         .confirm(1)
 
       check receipt.status == TransactionStatus.Success
-
-    test "can cancel procs that execute transactions":
-      let signer = provider.getSigner()
-      let token = TestToken.new(token.address, signer)
-      let countBefore = await signer.getTransactionCount(BlockTag.pending)
-
-      proc executeTx {.async.} =
-        discard await token.mint(accounts[0], 100.u256)
-
-      await executeTx().cancelAndWait()
-      let countAfter = await signer.getTransactionCount(BlockTag.pending)
-      check countBefore == countAfter
-
-    test "concurrent transactions succeed even if one is cancelled":
-      let signer = provider.getSigner()
-      let token = TestToken.new(token.address, signer)
-      let balanceBefore = await token.myBalance()
-
-      proc executeTx: Future[Confirmable] {.async.} =
-        return await token.mint(accounts[0], 100.u256)
-
-      proc executeTxWithCancellation: Future[Confirmable] {.async.} =
-        let fut = token.mint(accounts[0], 100.u256)
-        fut.cancelSoon()
-        return await fut
-
-      # emulate concurrent populateTransaction/sendTransaction calls, where the
-      # first one fails
-      let futs = await allFinished(
-        executeTxWithCancellation(),
-        executeTx(),
-        executeTx()
-      )
-      let receipt1 = await futs[1].confirm(1)
-      let receipt2 = await futs[2].confirm(1)
-
-      check receipt1.status == TransactionStatus.Success
-      check receipt2.status == TransactionStatus.Success
-
-      let balanceAfter = await token.myBalance()
-      check balanceAfter == balanceBefore + 200.u256

testmodule/testCustomErrors.nim

@@ -1,161 +0,0 @@
-import std/os
-import pkg/serde
-import pkg/asynctest/chronos/unittest
-import pkg/ethers
-import ./hardhat
-
-suite "Contract custom errors":
-
-  type
-    TestCustomErrors = ref object of Contract
-    SimpleError = object of SolidityError
-    ErrorWithArguments = object of SolidityError
-      arguments: tuple[one: UInt256, two: bool]
-    ErrorWithStaticStruct = object of SolidityError
-      arguments: tuple[one: Static, two: Static]
-    ErrorWithDynamicStruct = object of SolidityError
-      arguments: tuple[one: Dynamic, two: Dynamic]
-    ErrorWithDynamicAndStaticStruct = object of SolidityError
-      arguments: tuple[one: Dynamic, two: Static]
-    Static = (UInt256, UInt256)
-    Dynamic = (string, UInt256)
-
-  var contract: TestCustomErrors
-  var provider: JsonRpcProvider
-  var snapshot: JsonNode
-  let providerUrl = getEnv("ETHERS_TEST_PROVIDER", "localhost:8545")
-
-  setup:
-    provider = JsonRpcProvider.new("http://" & providerUrl)
-    snapshot = await provider.send("evm_snapshot")
-    let deployment = readDeployment()
-    let address = !deployment.address(TestCustomErrors)
-    contract = TestCustomErrors.new(address, provider)
-
-  teardown:
-    discard await provider.send("evm_revert", @[snapshot])
-    await provider.close()
-
-  test "handles simple errors":
-    proc revertsSimpleError(contract: TestCustomErrors)
-      {.contract, pure, errors:[SimpleError].}
-
-    expect SimpleError:
-      await contract.revertsSimpleError()
-
-  test "handles error with arguments":
-    proc revertsErrorWithArguments(contract: TestCustomErrors)
-      {.contract, pure, errors:[ErrorWithArguments].}
-
-    try:
-      await contract.revertsErrorWithArguments()
-      fail()
-    except ErrorWithArguments as error:
-      check error.arguments.one == 1
-      check error.arguments.two == true
-
-  test "handles error with static struct arguments":
-    proc revertsErrorWithStaticStruct(contract: TestCustomErrors)
-      {.contract, pure, errors:[ErrorWithStaticStruct].}
-
-    try:
-      await contract.revertsErrorWithStaticStruct()
-      fail()
-    except ErrorWithStaticStruct as error:
-      check error.arguments.one == (1.u256, 2.u256)
-      check error.arguments.two == (3.u256, 4.u256)
-
-  test "handles error with dynamic struct arguments":
-    proc revertsErrorWithDynamicStruct(contract: TestCustomErrors)
-      {.contract, pure, errors:[ErrorWithDynamicStruct].}
-
-    try:
-      await contract.revertsErrorWithDynamicStruct()
-      fail()
-    except ErrorWithDynamicStruct as error:
-      check error.arguments.one == ("1", 2.u256)
-      check error.arguments.two == ("3", 4.u256)
-
-  test "handles error with dynamic and static struct arguments":
-    proc revertsErrorWithDynamicAndStaticStruct(contract: TestCustomErrors)
-      {.contract, pure, errors:[ErrorWithDynamicAndStaticStruct].}
-
-    try:
-      await contract.revertsErrorWithDynamicAndStaticStruct()
-      fail()
-    except ErrorWithDynamicAndStaticStruct as error:
-      check error.arguments.one == ("1", 2.u256)
-      check error.arguments.two == (3.u256, 4.u256)
-
-  test "handles multiple error types":
-    proc revertsMultipleErrors(contract: TestCustomErrors, simple: bool)
-      {.contract, errors:[SimpleError, ErrorWithArguments].}
-
-    let contract = contract.connect(provider.getSigner())
-    expect SimpleError:
-      await contract.revertsMultipleErrors(simple = true)
-    expect ErrorWithArguments:
-      await contract.revertsMultipleErrors(simple = false)
-
-  test "handles gas estimation errors when calling a contract function":
-    proc revertsTransaction(contract: TestCustomErrors)
-      {.contract, errors:[ErrorWithArguments].}
-
-    let contract = contract.connect(provider.getSigner())
-    try:
-      await contract.revertsTransaction()
-      fail()
-    except ErrorWithArguments as error:
-      check error.arguments.one == 1.u256
-      check error.arguments.two == true
-
-  test "handles errors when only doing gas estimation":
-    proc revertsTransaction(contract: TestCustomErrors)
-      {.contract, errors:[ErrorWithArguments], used.}
-
-    let contract = contract.connect(provider.getSigner())
-    try:
-      discard await contract.estimateGas.revertsTransaction()
-      fail()
-    except ErrorWithArguments as error:
-      check error.arguments.one == 1.u256
-      check error.arguments.two == true
-
-  test "handles transaction submission errors":
-    proc revertsTransaction(contract: TestCustomErrors)
-      {.contract, errors:[ErrorWithArguments].}
-
-     # skip gas estimation
-    let overrides = TransactionOverrides(gasLimit: some 1000000.u256)
-
-    let contract = contract.connect(provider.getSigner())
-    try:
-      await contract.revertsTransaction(overrides = overrides)
-      fail()
-    except ErrorWithArguments as error:
-      check error.arguments.one == 1.u256
-      check error.arguments.two == true
-
-  test "handles transaction confirmation errors":
-    proc revertsTransaction(contract: TestCustomErrors): Confirmable
-      {.contract, errors:[ErrorWithArguments].}
-
-     # skip gas estimation
-    let overrides = TransactionOverrides(gasLimit: some 1000000.u256)
-
-    # ensure that transaction is not immediately checked by hardhat
-    discard await provider.send("evm_setAutomine", @[%false])
-
-    let contract = contract.connect(provider.getSigner())
-    try:
-      let future = contract.revertsTransaction(overrides = overrides).confirm(1)
-      await sleepAsync(100.millis) # wait for transaction to be submitted
-      discard await provider.send("evm_mine", @[]) # mine the transaction
-      discard await future # wait for confirmation
-      fail()
-    except ErrorWithArguments as error:
-      check error.arguments.one == 1.u256
-      check error.arguments.two == true
-
-    # re-enable auto mining
-    discard await provider.send("evm_setAutomine", @[%true])

testmodule/testEnums.nim

@@ -1,7 +1,5 @@
-import std/os
-import pkg/asynctest/chronos/unittest
+import pkg/asynctest
 import pkg/ethers
-import pkg/serde
 import ./hardhat
 
 type
@@ -15,10 +13,9 @@ suite "Contract enum parameters and return values":
   var contract: TestEnums
   var provider: JsonRpcProvider
   var snapshot: JsonNode
-  let providerUrl = getEnv("ETHERS_TEST_PROVIDER", "localhost:8545")
 
   setup:
-    provider = JsonRpcProvider.new("http://" & providerUrl)
+    provider = JsonRpcProvider.new()
     snapshot = await provider.send("evm_snapshot")
     let deployment = readDeployment()
     contract = TestEnums.new(!deployment.address(TestEnums), provider)

testmodule/testErc20.nim

@@ -1,6 +1,5 @@
-import std/os
-import pkg/serde
-import pkg/asynctest/chronos/unittest
+import std/json
+import pkg/asynctest
 import pkg/questionable
 import pkg/stint
 import pkg/ethers
@@ -10,10 +9,9 @@ import ./hardhat
 type
   TestToken = ref object of Erc20Token
 
-method mint(token: TestToken, holder: Address, amount: UInt256): Confirmable {.base, contract.}
+method mint(token: TestToken, holder: Address, amount: UInt256): ?TransactionResponse {.base, contract.}
 
-let providerUrl = getEnv("ETHERS_TEST_PROVIDER", "localhost:8545")
-for url in ["ws://" & providerUrl, "http://"  & providerUrl]:
+for url in ["ws://localhost:8545", "http://localhost:8545"]:
 
   suite "ERC20 (" & url & ")":
 

testmodule/testErrorDecoding.nim

@@ -1,56 +0,0 @@
-import std/unittest
-import std/strutils
-import pkg/questionable/results
-import pkg/contractabi
-import pkg/ethers/errors
-import pkg/ethers/contracts/errors/encoding
-
-suite "Decoding of custom errors":
-
-  type
-    SimpleError = object of SolidityError
-    ErrorWithArguments = object of SolidityError
-      arguments: tuple[one: UInt256, two: bool]
-
-  test "decodes a simple error":
-    let decoded = SimpleError.decode(@[0xc2'u8, 0xbb, 0x94, 0x7c])
-    check decoded is ?!(ref SimpleError)
-    check decoded.isSuccess
-    check (!decoded).msg.contains("SimpleError()")
-
-  test "decodes error with arguments":
-    let expected = (ref ErrorWithArguments)(arguments: (1.u256, true))
-    let encoded = AbiEncoder.encode(expected)
-    let decoded = ErrorWithArguments.decode(encoded)
-    check decoded.isSuccess
-    check (!decoded).arguments.one == 1.u256
-    check (!decoded).arguments.two == true
-    check (!decoded).msg.contains("ErrorWithArguments(one: 1, two: true)")
-
-  test "returns failure when decoding fails":
-    let invalid = @[0xc2'u8, 0xbb, 0x94, 0x0] # last byte is wrong
-    let decoded = SimpleError.decode(invalid)
-    check decoded.isFailure
-
-  test "returns failure when data is less than 4 bytes":
-    let invalid = @[0xc2'u8, 0xbb, 0x94]
-    let decoded = SimpleError.decode(invalid)
-    check decoded.isFailure
-
-  test "returns failure when there are trailing bytes":
-    let invalid = @[0xc2'u8, 0xbb, 0x94, 0x7c, 0x0] # one byte too many
-    let decoded = SimpleError.decode(invalid)
-    check decoded.isFailure
-
-  test "returns failure when there are trailing bytes after arguments":
-    let error = (ref ErrorWithArguments)(arguments: (1.u256, true))
-    let encoded = AbiEncoder.encode(error)
-    let invalid = encoded & @[0x0'u8] # one byte too many
-    let decoded = ErrorWithArguments.decode(invalid)
-    check decoded.isFailure
-
-  test "decoding only works for SolidityErrors":
-    type InvalidError = ref object of CatchableError
-    const works = compiles:
-      InvalidError.decode(@[0x1'u8, 0x2, 0x3, 0x4])
-    check not works

testmodule/testEvents.nim

@@ -1,4 +1,4 @@
-import pkg/asynctest/chronos/unittest
+import pkg/asynctest
 import pkg/ethers
 import pkg/contractabi
 import ./examples

testmodule/testGasEstimation.nim

@@ -1,77 +0,0 @@
-import std/os
-import pkg/asynctest/chronos/unittest
-import pkg/ethers
-import pkg/serde
-import ./hardhat
-
-type
-  TestGasEstimation = ref object of Contract
-
-proc getTime(contract: TestGasEstimation): UInt256 {.contract, view.}
-proc checkTimeEquals(contract: TestGasEstimation, expected: UInt256) {.contract.}
-
-suite "gas estimation":
-
-  var contract: TestGasEstimation
-  var provider: JsonRpcProvider
-  var snapshot: JsonNode
-  let providerUrl = getEnv("ETHERS_TEST_PROVIDER", "localhost:8545")
-
-  setup:
-    provider = JsonRpcProvider.new("http://" & providerUrl)
-    snapshot = await provider.send("evm_snapshot")
-    let deployment = readDeployment()
-    let signer = provider.getSigner()
-    contract = TestGasEstimation.new(!deployment.address(TestGasEstimation), signer)
-
-  teardown:
-    discard await provider.send("evm_revert", @[snapshot])
-    await provider.close()
-
-  test "contract function calls use pending block for gas estimations":
-    let latest = CallOverrides(blockTag: some BlockTag.latest)
-    let pending = CallOverrides(blockTag: some BlockTag.pending)
-
-    # retrieve time of pending block
-    let time = await contract.getTime(overrides=pending)
-
-    # ensure that time of latest block and pending block differ
-    check (await contract.getTime(overrides=latest)) != time
-
-    # only succeeds when gas estimation is done using the pending block,
-    # otherwise it will fail with "Transaction ran out of gas"
-    await contract.checkTimeEquals(time)
-
-  test "contract gas estimation uses pending block":
-    let latest = CallOverrides(blockTag: some BlockTag.latest)
-    let pending = CallOverrides(blockTag: some BlockTag.pending)
-
-    # retrieve time of pending block
-    let time = await contract.getTime(overrides=pending)
-
-    # ensure that time of latest block and pending block differ
-    check (await contract.getTime(overrides=latest)) != time
-
-    # estimate gas
-    let gas = await contract.estimateGas.checkTimeEquals(time)
-    let overrides = TransactionOverrides(gasLimit: some gas)
-
-    # only succeeds when gas estimation is done using the pending block,
-    # otherwise it will fail with "Transaction ran out of gas"
-    await contract.checkTimeEquals(time, overrides)
-
-  test "contract gas estimation honors a block tag override":
-    let latest = CallOverrides(blockTag: some BlockTag.latest)
-    let pending = CallOverrides(blockTag: some BlockTag.pending)
-
-    # retrieve time of pending block
-    let time = await contract.getTime(overrides=pending)
-
-    # ensure that time of latest block and pending block differ
-    check (await contract.getTime(overrides=latest)) != time
-
-    # estimate gas
-    let gasLatest = await contract.estimateGas.checkTimeEquals(time, latest)
-    let gasPending = await contract.estimateGas.checkTimeEquals(time, pending)
-
-    check gasLatest != gasPending

testmodule/testReturns.nim

@@ -1,7 +1,5 @@
-import std/os
-import pkg/asynctest/chronos/unittest
+import pkg/asynctest
 import pkg/ethers
-import pkg/serde
 import ./hardhat
 
 type
@@ -14,10 +12,9 @@ suite "Contract return values":
   var contract: TestReturns
   var provider: JsonRpcProvider
   var snapshot: JsonNode
-  let providerUrl = getEnv("ETHERS_TEST_PROVIDER", "localhost:8545")
 
   setup:
-    provider = JsonRpcProvider.new("http://" & providerUrl)
+    provider = JsonRpcProvider.new()
     snapshot = await provider.send("evm_snapshot")
     let deployment = readDeployment()
     contract = TestReturns.new(!deployment.address(TestReturns), provider)
@@ -55,11 +52,3 @@ suite "Contract return values":
     let values = await contract.getDynamics()
     check values.a == ("1", 2.u256)
     check values.b == ("3", 4.u256)
-
-  test "handles static size struct as a public state variable":
-    proc staticVariable(contract: TestReturns): Static {.contract, getter.}
-    check (await contract.staticVariable()) == (1.u256, 2.u256)
-
-  test "handles dynamic size struct as a public state variable":
-    proc dynamicVariable(contract: TestReturns): Dynamic {.contract, getter.}
-    check (await contract.dynamicVariable()) == ("3", 4.u256)

testmodule/testTesting.nim

@@ -1,10 +1,8 @@
-import std/os
 import std/strformat
-import pkg/asynctest/chronos/unittest
+import pkg/asynctest
 import pkg/chronos
 import pkg/ethers
 import pkg/ethers/testing
-import pkg/serde
 import ./helpers
 
 suite "Testing helpers":
@@ -33,15 +31,12 @@ suite "Testing helpers":
   test "reverts only checks ProviderErrors, EstimateGasErrors":
     proc callProviderError() {.async.} =
       raise newException(ProviderError, "test")
-    proc callSignerError() {.async.} =
-      raise newException(SignerError, "test")
     proc callEstimateGasError() {.async.} =
       raise newException(EstimateGasError, "test")
     proc callEthersError() {.async.} =
       raise newException(EthersError, "test")
 
     check await callProviderError().reverts()
-    check await callSignerError().reverts()
     check await callEstimateGasError().reverts()
     expect EthersError:
       check await callEthersError().reverts()
@@ -49,15 +44,12 @@ suite "Testing helpers":
   test "reverts with reason only checks ProviderErrors, EstimateGasErrors":
     proc callProviderError() {.async.} =
       raise newException(ProviderError, revertReason)
-    proc callSignerError() {.async.} =
-      raise newException(SignerError, revertReason)
     proc callEstimateGasError() {.async.} =
       raise newException(EstimateGasError, revertReason)
     proc callEthersError() {.async.} =
       raise newException(EthersError, revertReason)
 
     check await callProviderError().reverts(revertReason)
-    check await callSignerError().reverts(revertReason)
     check await callEstimateGasError().reverts(revertReason)
     expect EthersError:
       check await callEthersError().reverts(revertReason)
@@ -93,10 +85,9 @@ suite "Testing helpers - contracts":
   var snapshot: JsonNode
   var accounts: seq[Address]
   let revertReason = "revert reason"
-  let providerUrl = getEnv("ETHERS_TEST_PROVIDER", "localhost:8545")
 
   setup:
-    provider = JsonRpcProvider.new("ws://" & providerUrl)
+    provider = JsonRpcProvider.new("ws://127.0.0.1:8545")
     snapshot = await provider.send("evm_snapshot")
     accounts = await provider.listAccounts()
     helpersContract = TestHelpers.new(provider.getSigner())

testmodule/testWallet.nim

@@ -1,6 +1,4 @@
-import std/os
-import pkg/asynctest/chronos/unittest
-import pkg/serde
+import pkg/asynctest
 import pkg/stew/byteutils
 import ../ethers
 
@@ -13,10 +11,9 @@ proc transfer*(erc20: Erc20, recipient: Address, amount: UInt256) {.contract.}
 suite "Wallet":
   var provider: JsonRpcProvider
   var snapshot: JsonNode
-  let providerUrl = getEnv("ETHERS_TEST_PROVIDER", "localhost:8545")
 
   setup:
-    provider = JsonRpcProvider.new("http://" & providerUrl)
+    provider = JsonRpcProvider.new()
     snapshot = await provider.send("evm_snapshot")
 
   teardown:
@@ -80,8 +77,8 @@ suite "Wallet":
       to: wallet.address,
       nonce: some 0.u256,
       chainId: some 31337.u256,
-      maxFeePerGas: some 2_000_000_000.u256,
-      maxPriorityFeePerGas: some 1_000_000_000.u256,
+      maxFee: some 2_000_000_000.u256,
+      maxPriorityFee: some 1_000_000_000.u256,
       gasLimit: some 21_000.u256
     )
     let signedTx = await wallet.signTransaction(tx)
@@ -115,8 +112,8 @@ suite "Wallet":
     let wallet = !Wallet.new(pk_with_funds, provider)
     let overrides = TransactionOverrides(
       nonce: some 0.u256,
-      maxFeePerGas: some 1_000_000_000.u256,
-      maxPriorityFeePerGas: some 1_000_000_000.u256,
+      maxFee: some 1_000_000_000.u256,
+      maxPriorityFee: some 1_000_000_000.u256,
       gasLimit: some 22_000.u256)
     let testToken = Erc20.new(wallet.address, wallet)
     await testToken.transfer(wallet.address, 24.u256, overrides)

testnode/contracts/TestCustomErrors.sol

@@ -1,58 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.4;
-
-contract TestCustomErrors {
-
-  error SimpleError();
-  error ErrorWithArguments(uint256 one, bool two);
-  error ErrorWithStaticStruct(StaticStruct one, StaticStruct two);
-  error ErrorWithDynamicStruct(DynamicStruct one, DynamicStruct two);
-  error ErrorWithDynamicAndStaticStruct(DynamicStruct one, StaticStruct two);
-
-  struct StaticStruct {
-    uint256 a;
-    uint256 b;
-  }
-
-  struct DynamicStruct {
-    string a;
-    uint256 b;
-  }
-
-  function revertsSimpleError() public pure {
-    revert SimpleError();
-  }
-
-  function revertsErrorWithArguments() public pure {
-    revert ErrorWithArguments(1, true);
-  }
-
-  function revertsErrorWithStaticStruct() public pure {
-    revert ErrorWithStaticStruct(StaticStruct(1, 2), StaticStruct(3, 4));
-  }
-
-  function revertsErrorWithDynamicStruct() public pure {
-    revert ErrorWithDynamicStruct(DynamicStruct("1", 2), DynamicStruct("3", 4));
-  }
-
-  function revertsErrorWithDynamicAndStaticStruct() public pure {
-    revert ErrorWithDynamicAndStaticStruct(
-      DynamicStruct("1", 2),
-      StaticStruct(3, 4)
-    );
-  }
-
-  function revertsMultipleErrors(bool simple) public pure {
-    if (simple) {
-      revert SimpleError();
-    }
-    revert ErrorWithArguments(1, false);
-  }
-
-  string private state;
-
-  function revertsTransaction() public {
-    state = "updated state";
-    revert ErrorWithArguments(1, true);
-  }
-}

testnode/contracts/TestGasEstimation.sol

@@ -1,22 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
-
-contract TestGasEstimation {
-
-  uint lastCheckedTime;
-
-  // this function returns a different value depending on whether
-  // it is called on the latest block, or on the pending block
-  function getTime() public view returns (uint) {
-    return block.timestamp;
-  }
-
-  // this function is designed to require a different amount of
-  // gas, depending on whether the parameter matches the block
-  // timestamp
-  function checkTimeEquals(uint expected) public {
-    if (expected == block.timestamp) {
-      lastCheckedTime = block.timestamp;
-    }
-  }
-}

testnode/contracts/TestReturns.sol

@@ -11,9 +11,6 @@ contract TestReturns {
     uint256 b;
   }
 
-  StaticStruct public staticVariable = StaticStruct(1, 2);
-  DynamicStruct public dynamicVariable = DynamicStruct("3", 4);
-
   function getStatic() external pure returns (StaticStruct memory) {
     return StaticStruct(1, 2);
   }

testnode/deploy/testcustomerrors.js

@@ -1,6 +0,0 @@
-module.exports = async ({ deployments, getNamedAccounts }) => {
-  const { deployer } = await getNamedAccounts();
-  await deployments.deploy("TestCustomErrors", { from: deployer });
-};
-
-module.exports.tags = ["TestCustomErrors"];

testnode/deploy/testgasestimation.js

@@ -1,6 +0,0 @@
-module.exports = async ({ deployments, getNamedAccounts }) => {
-  const { deployer } = await getNamedAccounts();
-  await deployments.deploy("TestGasEstimation", { from: deployer });
-};
-
-module.exports.tags = ["TestGasEstimation"];

testnode/hardhat.config.js

@@ -2,7 +2,7 @@ require("hardhat-deploy")
 require("hardhat-deploy-ethers")
 
 module.exports = {
-  solidity: "0.8.24",
+  solidity: "0.8.11",
   namedAccounts: {
     deployer: { default: 0 }
   }

testnode/package.json

@@ -2,10 +2,10 @@
   "name": "hardhat-project",
   "devDependencies": {
     "@openzeppelin/contracts": "^4.4.2",
-    "ethers": "^6.11.1",
-    "hardhat": "^2.22.1",
-    "hardhat-deploy": "^0.11.34",
-    "hardhat-deploy-ethers": "^0.4.1"
+    "ethers": "^5.5.3",
+    "hardhat": "^2.8.3",
+    "hardhat-deploy": "^0.9.24",
+    "hardhat-deploy-ethers": "^0.3.0-beta.13"
   },
   "scripts": {
     "start": "hardhat node --export 'deployment.json'"