chore: bump eth (#124 )

* recycle common transaction signature helpers * bump versions
chore: add EIP-1559 implementation for gas price (#113 )
2026-01-02 13:43:06 +00:00 · 2025-12-13 07:32:36 +01:00 · 2025-05-28 16:14:01 +02:00 · 2025-04-15 10:55:57 +02:00 · 2025-04-15 10:45:52 +02:00 · 2025-04-15 10:45:52 +02:00
71 changed files with 7896 additions and 2571 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -1,31 +1,53 @@
 name: CI

-on: [push, pull_request]
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+  workflow_dispatch:

 jobs:
  test:
    runs-on: ubuntu-latest
+    timeout-minutes: 30
    strategy:
      matrix:
-        nim: [1.6.16, stable]
+        nim: [2.0.14, 2.2.2]
    steps:
    - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
+      with:
+        ref: ${{ github.event.pull_request.head.sha }}
+
    - name: Install Nim
-      uses: iffy/install-nim@v3
+      uses: iffy/install-nim@v4
      with:
        version: ${{ matrix.nim }}
+
    - name: Install NodeJS
-      uses: actions/setup-node@v2
+      uses: actions/setup-node@v4
      with:
-        node-version: '14'
+        node-version: 18
+
    - 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
+      run: nimble install -y --maximumtaggedversions=2
+
    - 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
--- a/.gitignore
+++ b/.gitignore
@ -4,3 +4,6 @@
 nimble.develop
 nimble.paths
 .idea
+.nimble
+.envrc
+nimbledeps
--- a/Readme.md
+++ b/Readme.md
@ -14,7 +14,13 @@ Use the [Nimble][2] package manager to add `ethers` to an existing
 project. Add the following to its .nimble file:

 ```nim
-requires "ethers >= 0.7.2 & < 0.8.0"
+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
 ```

 Usage
@ -131,14 +137,22 @@ You can now subscribe to Transfer events by calling `subscribe` on the contract
 instance.

 ```nim
-proc handleTransfer(transfer: Transfer) =
-  echo "received transfer: ", transfer
+proc handleTransfer(transferResult: ?!Transfer) =
+  if transferResult.isOk:
+    echo "received transfer: ", transferResult.value
+  else:
+    echo "error during transfer: ", transferResult.error.msg

 let subscription = await token.subscribe(Transfer, handleTransfer)
 ```

 When a Transfer event is emitted, the `handleTransfer` proc that you just
-defined will be called.
+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.

 When you're no longer interested in these events, you can unsubscribe:

@ -146,6 +160,43 @@ 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
 ---------

@ -153,6 +204,13 @@ 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
 ------------

@ -165,6 +223,9 @@ $ 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
 ------

@ -175,3 +236,5 @@ 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/
--- a/config.nims
+++ b/config.nims
@ -5,3 +5,6 @@
 when fileExists("nimble.paths"):
  include "nimble.paths"
 # end Nimble config
+
+when (NimMajor, NimMinor) >= (2, 0):
+  --mm:refc
--- a/ethers.nim
+++ b/ethers.nim
@ -1,11 +1,11 @@
 import ./ethers/provider
 import ./ethers/signer
 import ./ethers/providers/jsonrpc
-import ./ethers/contract
+import ./ethers/contracts
 import ./ethers/wallet

 export provider
 export signer
 export jsonrpc
-export contract
-export wallet
+export contracts
+export wallet
--- a/ethers.nimble
+++ b/ethers.nimble
@ -1,20 +1,20 @@
-version = "0.7.2"
+version = "2.1.0"
 author = "Nim Ethers Authors"
 description = "library for interacting with Ethereum"
 license = "MIT"

-requires "nim >= 1.6.0"
-requires "chronicles >= 0.10.3 & < 0.11.0"
-requires "chronos >= 4.0.0 & < 4.1.0"
-requires "contractabi >= 0.6.0 & < 0.7.0"
+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 "questionable >= 0.10.2 & < 0.11.0"
-requires "json_rpc >= 0.4.0 & < 0.5.0"
-requires "serde >= 0.1.1 & < 0.2.0"
-requires "stint"
-requires "stew"
-requires "eth"
+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"

 task test, "Run the test suite":
-  exec "nimble install -d -y"
+  # exec "nimble install -d -y"
  withDir "testmodule":
    exec "nimble test"
--- a/ethers/blocktag.nim
+++ b/ethers/blocktag.nim
@ -1,4 +1,5 @@
 import pkg/stint
+import pkg/questionable

 {.push raises:[].}

@ -34,3 +35,17 @@ 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
--- a/ethers/contract.nim
+++ b/ethers/contract.nim
@ -1,310 +0,0 @@
-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)
--- a/ethers/contracts.nim
+++ b/ethers/contracts.nim
@ -0,0 +1,31 @@
+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)
+  )
--- a/ethers/contracts/confirmation.nim
+++ b/ethers/contracts/confirmation.nim
@ -0,0 +1,45 @@
+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
+    )
+
--- a/ethers/contracts/contract.nim
+++ b/ethers/contracts/contract.nim
@ -0,0 +1,36 @@
+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
+
--- a/ethers/contracts/contractcall.nim
+++ b/ethers/contracts/contractcall.nim
@ -0,0 +1,35 @@
+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
--- a/ethers/contracts/errors.nim
+++ b/ethers/contracts/errors.nim
@ -0,0 +1,29 @@
+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
--- a/ethers/contracts/errors/conversion.nim
+++ b/ethers/contracts/errors/conversion.nim
@ -0,0 +1,15 @@
+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
--- a/ethers/contracts/errors/encoding.nim
+++ b/ethers/contracts/errors/encoding.nim
@ -0,0 +1,37 @@
+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)
+
--- a/ethers/contracts/events.nim
+++ b/ethers/contracts/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
--- a/ethers/contracts/fields.nim
+++ b/ethers/contracts/fields.nim
--- a/ethers/contracts/filters.nim
+++ b/ethers/contracts/filters.nim
@ -0,0 +1,78 @@
+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)
--- a/ethers/contracts/function.nim
+++ b/ethers/contracts/function.nim
@ -0,0 +1,60 @@
+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()
+
--- a/ethers/contracts/gas.nim
+++ b/ethers/contracts/gas.nim
@ -0,0 +1,51 @@
+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()
--- a/ethers/contracts/overrides.nim
+++ b/ethers/contracts/overrides.nim
@ -0,0 +1,13 @@
+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
--- a/ethers/contracts/syntax.nim
+++ b/ethers/contracts/syntax.nim
@ -0,0 +1,76 @@
+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)
--- a/ethers/contracts/transactions.nim
+++ b/ethers/contracts/transactions.nim
@ -0,0 +1,71 @@
+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
+
--- a/ethers/erc20.nim
+++ b/ethers/erc20.nim
@ -46,17 +46,17 @@ method allowance*(token: Erc20Token,

 method transfer*(token: Erc20Token,
                 recipient: Address,
-                 amount: UInt256): ?TransactionResponse {.base, contract.}
+                 amount: UInt256): Confirmable {.base, contract.}
  ## Moves `amount` tokens from the caller's account to `recipient`.

 method approve*(token: Erc20Token,
                spender: Address,
-                amount: UInt256): ?TransactionResponse {.base, contract.}
+                amount: UInt256): Confirmable {.base, contract.}
  ## Sets `amount` as the allowance of `spender` over the caller's tokens.

 method increaseAllowance*(token: Erc20Token,
                spender: Address,
-                addedValue: UInt256): ?TransactionResponse {.base, contract.}
+                addedValue: UInt256): Confirmable {.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): ?TransactionResponse {.base, contract.}
+                addedValue: UInt256): Confirmable {.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): ?TransactionResponse {.base, contract.}
+                     amount: UInt256): Confirmable {.base, contract.}
  ## Moves `amount` tokens from `spender` to `recipient` using the allowance
  ## mechanism. `amount` is then deducted from the caller's allowance.
--- a/ethers/errors.nim
+++ b/ethers/errors.nim
@ -0,0 +1,18 @@
+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)
--- a/ethers/nimshims/hashes.nim
+++ b/ethers/nimshims/hashes.nim
@ -2,7 +2,7 @@
 ## `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 std/json
+import pkg/serde
 import std/hashes

 {.push raises:[].}
--- a/ethers/provider.nim
+++ b/ethers/provider.nim
@ -1,19 +1,22 @@
 import pkg/chronicles
 import pkg/serde
-import pkg/stew/byteutils
+import pkg/questionable
 import ./basics
 import ./transaction
 import ./blocktag
+import ./errors

 export basics
 export transaction
 export blocktag
+export errors

 {.push raises: [].}

 type
  Provider* = ref object of RootObj
-  ProviderError* = object of EthersError
+  EstimateGasError* = object of ProviderError
+    transaction*: Transaction
  Subscription* = ref object of RootObj
  EventFilter* {.serialize.} = ref object of RootObj
    address*: Address
@ -53,13 +56,14 @@ type
    effectiveGasPrice*: ?UInt256
    status*: TransactionStatus
    transactionType* {.serialize("type"), deserialize("type").}: TransactionType
-  LogHandler* = proc(log: Log) {.gcsafe, raises:[].}
-  BlockHandler* = proc(blck: Block) {.gcsafe, raises:[].}
+  LogHandler* = proc(log: ?!Log) {.gcsafe, raises:[].}
+  BlockHandler* = proc(blck: ?!Block) {.gcsafe, raises:[].}
  Topic* = array[32, byte]
  Block* {.serialize.} = object
    number*: ?UInt256
    timestamp*: UInt256
    hash*: ?BlockHash
+    baseFeePerGas* : ?UInt256
  PastTransaction* {.serialize.} = object
    blockHash*: BlockHash
    blockNumber*: UInt256
@ -99,96 +103,90 @@ func toTransaction*(past: PastTransaction): Transaction =
  )

 method getBlockNumber*(
-  provider: Provider): Future[UInt256] {.base, async: (raises:[ProviderError]).} =
-
+    provider: Provider
+): Future[UInt256] {.base, async: (raises: [ProviderError, CancelledError]).} =
  doAssert false, "not implemented"

 method getBlock*(
-  provider: Provider,
-  tag: BlockTag): Future[?Block] {.base, async: (raises:[ProviderError]).} =
-
+    provider: Provider, tag: BlockTag
+): Future[?Block] {.base, async: (raises: [ProviderError, CancelledError]).} =
  doAssert false, "not implemented"

 method call*(
-  provider: Provider,
-  tx: Transaction,
-  blockTag = BlockTag.latest): Future[seq[byte]] {.base, async: (raises:[ProviderError]).} =
-
+    provider: Provider, tx: Transaction, blockTag = BlockTag.latest
+): Future[seq[byte]] {.base, async: (raises: [ProviderError, CancelledError]).} =
  doAssert false, "not implemented"

 method getGasPrice*(
-  provider: Provider): Future[UInt256] {.base, async: (raises:[ProviderError]).} =
+    provider: Provider
+): Future[UInt256] {.base, async: (raises: [ProviderError, CancelledError]).} =
+  doAssert false, "not implemented"

+method getMaxPriorityFeePerGas*(
+    provider: Provider
+): Future[UInt256] {.base, async: (raises: [CancelledError]).} =
  doAssert false, "not implemented"

 method getTransactionCount*(
-  provider: Provider,
-  address: Address,
-  blockTag = BlockTag.latest): Future[UInt256] {.base, async: (raises:[ProviderError]).} =
-
+    provider: Provider, address: Address, blockTag = BlockTag.latest
+): Future[UInt256] {.base, async: (raises: [ProviderError, CancelledError]).} =
  doAssert false, "not implemented"

 method getTransaction*(
-  provider: Provider,
-  txHash: TransactionHash): Future[?PastTransaction] {.base, async: (raises:[ProviderError]).} =
-
+    provider: Provider, txHash: TransactionHash
+): Future[?PastTransaction] {.base, async: (raises: [ProviderError, CancelledError]).} =
  doAssert false, "not implemented"

 method getTransactionReceipt*(
-  provider: Provider,
-  txHash: TransactionHash): Future[?TransactionReceipt] {.base, async: (raises:[ProviderError]).} =
-
+    provider: Provider, txHash: TransactionHash
+): Future[?TransactionReceipt] {.
+    base, async: (raises: [ProviderError, CancelledError])
+.} =
  doAssert false, "not implemented"

 method sendTransaction*(
-  provider: Provider,
-  rawTransaction: seq[byte]): Future[TransactionResponse] {.base, async: (raises:[ProviderError]).} =
-
+    provider: Provider, rawTransaction: seq[byte]
+): Future[TransactionResponse] {.
+    base, async: (raises: [ProviderError, CancelledError])
+.} =
  doAssert false, "not implemented"

 method getLogs*(
-  provider: Provider,
-  filter: EventFilter): Future[seq[Log]] {.base, async: (raises:[ProviderError]).} =
-
+    provider: Provider, filter: EventFilter
+): Future[seq[Log]] {.base, async: (raises: [ProviderError, CancelledError]).} =
  doAssert false, "not implemented"

 method estimateGas*(
-  provider: Provider,
-  transaction: Transaction,
-  blockTag = BlockTag.latest): Future[UInt256] {.base, async: (raises:[ProviderError]).} =
-
+    provider: Provider, transaction: Transaction, blockTag = BlockTag.latest
+): Future[UInt256] {.base, async: (raises: [ProviderError, CancelledError]).} =
  doAssert false, "not implemented"

 method getChainId*(
-  provider: Provider): Future[UInt256] {.base, async: (raises:[ProviderError]).} =
-
+    provider: Provider
+): Future[UInt256] {.base, async: (raises: [ProviderError, CancelledError]).} =
  doAssert false, "not implemented"

 method subscribe*(
-  provider: Provider,
-  filter: EventFilter,
-  callback: LogHandler): Future[Subscription] {.base, async: (raises:[ProviderError]).} =
-
+    provider: Provider, filter: EventFilter, callback: LogHandler
+): Future[Subscription] {.base, async: (raises: [ProviderError, CancelledError]).} =
  doAssert false, "not implemented"

 method subscribe*(
-  provider: Provider,
-  callback: BlockHandler): Future[Subscription] {.base, async: (raises:[ProviderError]).} =
-
+    provider: Provider, callback: BlockHandler
+): Future[Subscription] {.base, async: (raises: [ProviderError, CancelledError]).} =
  doAssert false, "not implemented"

 method unsubscribe*(
-  subscription: Subscription) {.base, async: (raises:[ProviderError]).} =
-
+    subscription: Subscription
+) {.base, async: (raises: [ProviderError, CancelledError]).} =
  doAssert false, "not implemented"

-method isSyncing*(provider: Provider): Future[bool] {.base, async.} =
+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]).} =
+    provider: Provider, tx: Transaction, blockNumber: UInt256
+) {.async: (raises: [ProviderError, CancelledError]).} =
  # 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
@ -199,77 +197,71 @@ 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: (raises: [ProviderError]).} =
-
-  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: (raises: [ProviderError]).} =
-
-  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]).} =
+    provider: Provider, receipt: TransactionReceipt
+) {.async: (raises: [ProviderError, CancelledError]).} =
  ## 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:
-    logScope:
-      transactionHash = receipt.transactionHash.to0xHex
+  if receipt.status != TransactionStatus.Failure:
+    return

-    trace "transaction failed, replaying transaction to get revert reason"
+  without blockNumber =? receipt.blockNumber and
+          pastTx =? await provider.getTransaction(receipt.transactionHash):
+    raiseProviderError("Transaction reverted with unknown reason")

-    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")
+  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, EthersError]).} =
+  {.async: (raises: [CancelledError, ProviderError, SubscriptionError, EthersError]).} =

  ## Waits for a transaction to be mined and for the specified number of blocks
-  ## to pass since it was mined (confirmations).
+  ## to pass since it was mined (confirmations). The number of confirmations
+  ## includes the block in which the transaction was mined.
  ## 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 onBlockNumber(number: UInt256) =
-    blockNumber = number
-    blockEvent.fire()
+  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 onBlock(blck: Block) =
-    if number =? blck.number:
-      onBlockNumber(number)
+  proc onBlock(blckResult: ?!Block) =
+    blockSubscriptionResult = blckResult

-  onBlockNumber(await tx.provider.getBlockNumber())
+    if blckResult.isErr:
+      blockEvent.fire()
+      return
+
+    # ignore block parameter; hardhat may call this with pending blocks
+    asyncSpawn updateBlockNumber()
+
+  await updateBlockNumber()
  let subscription = await tx.provider.subscribe(onBlock)

  let finish = blockNumber + timeout.u256
@ -279,6 +271,16 @@ 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")
@ -297,13 +299,24 @@ proc confirm*(
 proc confirm*(
  tx: Future[TransactionResponse],
  confirmations: int = EthersDefaultConfirmations,
-  timeout: int = EthersReceiptTimeoutBlks): Future[TransactionReceipt] {.async.} =
+  timeout: int = EthersReceiptTimeoutBlks): Future[TransactionReceipt] {.async: (raises: [CancelledError, EthersError]).} =
  ## 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
+    )

-  let txResp = await tx
-  return await txResp.confirm(confirmations, timeout)
-
-method close*(provider: Provider) {.base, async: (raises:[ProviderError]).} =
+method close*(
+    provider: Provider
+) {.base, async: (raises: [ProviderError, CancelledError]).} =
  discard
--- a/ethers/providers/jsonrpc.nim
+++ b/ethers/providers/jsonrpc.nim
@ -1,7 +1,7 @@
 import std/tables
 import std/uri
 import pkg/chronicles
-import pkg/eth/common/eth_types_json_serialization
+import pkg/eth/common/eth_types except Block, Log, Address, Transaction
 import pkg/json_rpc/rpcclient
 import pkg/json_rpc/errors
 import pkg/serde
@ -11,10 +11,13 @@ import ../signer
 import ./jsonrpc/rpccalls
 import ./jsonrpc/conversions
 import ./jsonrpc/subscriptions
+import ./jsonrpc/errors

 export basics
 export provider
 export chronicles
+export errors.JsonRpcProviderError
+export subscriptions

 {.push raises: [].}

@ -25,8 +28,8 @@ type
  JsonRpcProvider* = ref object of Provider
    client: Future[RpcClient]
    subscriptions: Future[JsonRpcSubscriptions]
+    maxPriorityFeePerGas: UInt256

-  JsonRpcProviderError* = object of ProviderError
  JsonRpcSubscription* = ref object of Subscription
    subscriptions: JsonRpcSubscriptions
    id: JsonNode
@ -37,27 +40,11 @@ type
    address: ?Address
  JsonRpcSignerError* = object of SignerError

-proc raiseJsonRpcProviderError(
-  message: string) {.raises: [JsonRpcProviderError].} =
-
-  var message = message
-  if json =? JsonNode.fromJson(message):
-    if "message" in json:
-      message = json{"message"}.getStr
-  raise newException(JsonRpcProviderError, message)
-
-template convertError(body) =
-  try:
-    body
-  except JsonRpcError as error:
-    raiseJsonRpcProviderError(error.msg)
-  except CatchableError 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")]
@ -65,13 +52,14 @@ proc jsonHeaders: seq[(string, string)] =
 proc new*(
  _: type JsonRpcProvider,
  url=defaultUrl,
-  pollingInterval=defaultPollingInterval): JsonRpcProvider {.raises: [JsonRpcProviderError].} =
+  pollingInterval=defaultPollingInterval,
+  maxPriorityFeePerGas=defaultMaxPriorityFeePerGas): JsonRpcProvider {.raises: [JsonRpcProviderError].} =

  var initialized: Future[void]
  var client: RpcClient
  var subscriptions: JsonRpcSubscriptions

-  proc initialize {.async: (raises:[JsonRpcProviderError]).} =
+  proc initialize() {.async: (raises: [JsonRpcProviderError, CancelledError]).} =
    convertError:
      case parseUri(url).scheme
      of "ws", "wss":
@ -87,43 +75,47 @@ proc new*(
                                                pollingInterval = pollingInterval)
      subscriptions.start()

-  proc awaitClient: Future[RpcClient] {.async:(raises:[JsonRpcProviderError]).} =
+  proc awaitClient(): Future[RpcClient] {.
+      async: (raises: [JsonRpcProviderError, CancelledError])
+  .} =
    convertError:
      await initialized
      return client

-  proc awaitSubscriptions: Future[JsonRpcSubscriptions] {.async:(raises:[JsonRpcProviderError]).} =
+  proc awaitSubscriptions(): Future[JsonRpcSubscriptions] {.
+      async: (raises: [JsonRpcProviderError, CancelledError])
+  .} =
    convertError:
      await initialized
      return subscriptions

  initialized = initialize()
-  return JsonRpcProvider(client: awaitClient(), subscriptions: awaitSubscriptions())
+  return JsonRpcProvider(client: awaitClient(), subscriptions: awaitSubscriptions(), maxPriorityFeePerGas: maxPriorityFeePerGas)

 proc callImpl(
-  client: RpcClient,
-  call: string,
-  args: JsonNode): Future[JsonNode] {.async: (raises: [JsonRpcProviderError]).} =
-
-  without response =? (await client.call(call, %args)).catch, error:
+    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
-  without json =? JsonNode.fromJson(response.string), error:
-    raiseJsonRpcProviderError "Failed to parse response: " & error.msg
-  json

 proc send*(
-  provider: JsonRpcProvider,
-  call: string,
-  arguments: seq[JsonNode] = @[]): Future[JsonNode]
-  {.async: (raises: [JsonRpcProviderError]).} =
-
+    provider: JsonRpcProvider, call: string, arguments: seq[JsonNode] = @[]
+): Future[JsonNode] {.async: (raises: [ProviderError, CancelledError]).} =
  convertError:
    let client = await provider.client
    return await client.callImpl(call, %arguments)

-proc listAccounts*(provider: JsonRpcProvider): Future[seq[Address]]
-  {.async: (raises: [JsonRpcProviderError]).} =
-
+proc listAccounts*(
+    provider: JsonRpcProvider
+): Future[seq[Address]] {.async: (raises: [JsonRpcProviderError, CancelledError]).} =
  convertError:
    let client = await provider.client
    return await client.eth_accounts()
@ -135,73 +127,78 @@ proc getSigner*(provider: JsonRpcProvider, address: Address): JsonRpcSigner =
  JsonRpcSigner(provider: provider, address: some address)

 method getBlockNumber*(
-  provider: JsonRpcProvider): Future[UInt256] {.async: (raises:[ProviderError]).} =
-
+    provider: JsonRpcProvider
+): Future[UInt256] {.async: (raises: [ProviderError, CancelledError]).} =
  convertError:
    let client = await provider.client
    return await client.eth_blockNumber()

 method getBlock*(
-  provider: JsonRpcProvider,
-  tag: BlockTag): Future[?Block] {.async: (raises:[ProviderError]).} =
-
+    provider: JsonRpcProvider, tag: BlockTag
+): Future[?Block] {.async: (raises: [ProviderError, CancelledError]).} =
  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]).} =
-
+    provider: JsonRpcProvider, tx: Transaction, blockTag = BlockTag.latest
+): Future[seq[byte]] {.async: (raises: [ProviderError, CancelledError]).} =
  convertError:
    let client = await provider.client
    return await client.eth_call(tx, blockTag)

 method getGasPrice*(
-  provider: JsonRpcProvider): Future[UInt256] {.async: (raises:[ProviderError]).} =
-
+    provider: JsonRpcProvider
+): Future[UInt256] {.async: (raises: [ProviderError, CancelledError]).} =
  convertError:
    let client = await provider.client
    return await client.eth_gasPrice()

-method getTransactionCount*(
-  provider: JsonRpcProvider,
-  address: Address,
-  blockTag = BlockTag.latest): Future[UInt256] {.async: (raises:[ProviderError]).} =
+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]).} =
  convertError:
    let client = await provider.client
    return await client.eth_getTransactionCount(address, blockTag)

 method getTransaction*(
-  provider: JsonRpcProvider,
-  txHash: TransactionHash): Future[?PastTransaction] {.async: (raises:[ProviderError]).} =
-
+    provider: JsonRpcProvider, txHash: TransactionHash
+): Future[?PastTransaction] {.async: (raises: [ProviderError, CancelledError]).} =
  convertError:
    let client = await provider.client
    return await client.eth_getTransactionByHash(txHash)

 method getTransactionReceipt*(
-  provider: JsonRpcProvider,
-  txHash: TransactionHash): Future[?TransactionReceipt] {.async: (raises:[ProviderError]).} =
-
+    provider: JsonRpcProvider, txHash: TransactionHash
+): Future[?TransactionReceipt] {.async: (raises: [ProviderError, CancelledError]).} =
  convertError:
    let client = await provider.client
    return await client.eth_getTransactionReceipt(txHash)

 method getLogs*(
-  provider: JsonRpcProvider,
-  filter: EventFilter): Future[seq[Log]] {.async: (raises:[ProviderError]).} =
-
+    provider: JsonRpcProvider, filter: EventFilter
+): Future[seq[Log]] {.async: (raises: [ProviderError, CancelledError]).} =
  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:
@ -211,29 +208,37 @@ method getLogs*(
    return logs

 method estimateGas*(
-  provider: JsonRpcProvider,
-  transaction: Transaction,
-  blockTag = BlockTag.latest): Future[UInt256] {.async: (raises:[ProviderError]).} =
-
-  convertError:
-    let client = await provider.client
-    return await client.eth_estimateGas(transaction, blockTag)
+    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 getChainId*(
-  provider: JsonRpcProvider): Future[UInt256] {.async: (raises:[ProviderError]).} =
-
+    provider: JsonRpcProvider
+): Future[UInt256] {.async: (raises: [ProviderError, CancelledError]).} =
  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]).} =
-
+    provider: JsonRpcProvider, rawTransaction: seq[byte]
+): Future[TransactionResponse] {.async: (raises: [ProviderError, CancelledError]).} =
  convertError:
    let
      client = await provider.client
@ -242,39 +247,40 @@ method sendTransaction*(
    return TransactionResponse(hash: hash, provider: provider)

 method subscribe*(
-  provider: JsonRpcProvider,
-  filter: EventFilter,
-  onLog: LogHandler): Future[Subscription] {.async: (raises:[ProviderError]).} =
-
+    provider: JsonRpcProvider, filter: EventFilter, onLog: LogHandler
+): Future[Subscription] {.async: (raises: [ProviderError, CancelledError]).} =
  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]).} =
-
+    provider: JsonRpcProvider, onBlock: BlockHandler
+): Future[Subscription] {.async: (raises: [ProviderError, CancelledError]).} =
  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]).} =
-
+    subscription: JsonRpcSubscription
+) {.async: (raises: [ProviderError, CancelledError]).} =
  convertError:
    let subscriptions = subscription.subscriptions
    let id = subscription.id
    await subscriptions.unsubscribe(id)

-method isSyncing*(provider: JsonRpcProvider): Future[bool] {.async.} =
+method isSyncing*(
+    provider: JsonRpcProvider
+): Future[bool] {.async: (raises: [ProviderError, CancelledError]).} =
  let response = await provider.send("eth_syncing")
+  if response.kind == JsonNodeKind.JObject:
+    return true
  return response.getBool()

 method close*(
-  provider: JsonRpcProvider) {.async: (raises:[ProviderError]).} =
-
+    provider: JsonRpcProvider
+) {.async: (raises: [ProviderError, CancelledError]).} =
  convertError:
    let client = await provider.client
    let subscriptions = await provider.subscriptions
@ -295,6 +301,8 @@ proc raiseJsonRpcSignerError(
 template convertSignerError(body) =
  try:
    body
+  except CancelledError as error:
+    raise error
  except JsonRpcError as error:
    raiseJsonRpcSignerError(error.msg)
  except CatchableError as error:
@ -306,9 +314,8 @@ method provider*(signer: JsonRpcSigner): Provider
  signer.provider

 method getAddress*(
-  signer: JsonRpcSigner): Future[Address]
-  {.async: (raises:[ProviderError, SignerError]).} =
-
+    signer: JsonRpcSigner
+): Future[Address] {.async: (raises: [ProviderError, SignerError, CancelledError]).} =
  if address =? signer.address:
    return address

@ -319,22 +326,19 @@ method getAddress*(
  raiseJsonRpcSignerError "no address found"

 method signMessage*(
-  signer: JsonRpcSigner,
-  message: seq[byte]): Future[seq[byte]] {.async: (raises:[SignerError]).} =
-
+    signer: JsonRpcSigner, message: seq[byte]
+): Future[seq[byte]] {.async: (raises: [SignerError, CancelledError]).} =
  convertSignerError:
    let client = await signer.provider.client
    let address = await signer.getAddress()
-    return await client.eth_sign(address, message)
+    return await client.personal_sign(message, address)

 method sendTransaction*(
-  signer: JsonRpcSigner,
-  transaction: Transaction): Future[TransactionResponse]
-  {.async: (raises:[SignerError]).} =
-
-  convertSignerError:
-    if nonce =? transaction.nonce:
-      signer.updateNonce(nonce)
+    signer: JsonRpcSigner, transaction: Transaction
+): Future[TransactionResponse] {.
+    async: (raises: [SignerError, ProviderError, CancelledError])
+.} =
+  convertError:
    let
      client = await signer.provider.client
      hash = await client.eth_sendTransaction(transaction)
--- a/ethers/providers/jsonrpc/conversions.nim
+++ b/ethers/providers/jsonrpc/conversions.nim
@ -1,7 +1,7 @@
 import std/strformat
 import std/strutils
 import pkg/chronicles except fromJson, `%`, `%*`, toJson
-import pkg/json_rpc/jsonmarshal
+import pkg/json_rpc/jsonmarshal except toJson
 import pkg/questionable/results
 import pkg/serde
 import pkg/stew/byteutils
@ -10,7 +10,7 @@ import ../../transaction
 import ../../blocktag
 import ../../provider

-export jsonmarshal
+export jsonmarshal except toJson
 export serde
 export chronicles except fromJson, `%`, `%*`, toJson

@ -47,11 +47,6 @@ func fromJson(_: type Address, json: JsonNode): ?!Address =
 func `%`*(integer: UInt256): JsonNode =
  %("0x" & toHex(integer))

-func fromJson*(_: type UInt256, json: JsonNode): ?!UInt256 =
-  without result =? UInt256.fromHex(json.getStr()).catch, error:
-    return UInt256.failure error.msg
-  success result
-
 # Transaction

 # TODO: add option that ignores none Option[T]
@ -81,7 +76,7 @@ func `%`*(tag: BlockTag): JsonNode =
 func fromJson*(_: type BlockTag, json: JsonNode): ?!BlockTag =
  expectJsonKind(BlockTag, JString, json)
  let jsonVal = json.getStr
-  if jsonVal[0..1].toLowerAscii == "0x":
+  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)
@ -95,12 +90,13 @@ func fromJson*(_: type BlockTag, json: JsonNode): ?!BlockTag =
      "' to BlockTag: must be one of 'earliest', 'latest', 'pending'")

 # TransactionStatus | TransactionType
+type TransactionEnums = TransactionStatus | TransactionType

-func `%`*(e: TransactionStatus | TransactionType): JsonNode =
+func `%`*(e: TransactionEnums): JsonNode =
  % ("0x" & e.int8.toHex(1))

-proc fromJson*[E: TransactionStatus | TransactionType](
-  T: type E,
+proc fromJson*(
+  T: type TransactionEnums,
  json: JsonNode
 ): ?!T =
  expectJsonKind(string, JString, json)
--- a/ethers/providers/jsonrpc/errors.nim
+++ b/ethers/providers/jsonrpc/errors.nim
@ -0,0 +1,49 @@
+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)
+
--- a/ethers/providers/jsonrpc/signatures.nim
+++ b/ethers/providers/jsonrpc/signatures.nim
@ -1,4 +1,5 @@
 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]
@ -13,7 +14,6 @@ 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,3 +21,4 @@ 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
--- a/ethers/providers/jsonrpc/subscriptions.nim
+++ b/ethers/providers/jsonrpc/subscriptions.nim
@ -1,24 +1,43 @@
 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
-import ./looping
+
+export serde

 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, arguments: 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

@ -40,7 +59,6 @@ func start*(subscriptions: JsonRpcSubscriptions) =
      # true = continue processing message using json_rpc's default message handler
      return ok true

-
 proc setMethodHandler(
  subscriptions: JsonRpcSubscriptions,
  `method`: string,
@ -51,153 +69,311 @@ proc setMethodHandler(
 method subscribeBlocks*(subscriptions: JsonRpcSubscriptions,
                        onBlock: BlockHandler):
                       Future[JsonNode]
-                       {.async, base.} =
+                       {.async: (raises: [SubscriptionError, CancelledError]), base,.} =
  raiseAssert "not implemented"

 method subscribeLogs*(subscriptions: JsonRpcSubscriptions,
                      filter: EventFilter,
                      onLog: LogHandler):
                     Future[JsonNode]
-                     {.async, base.} =
+                     {.async: (raises: [SubscriptionError, CancelledError]), base.} =
  raiseAssert "not implemented"

 method unsubscribe*(subscriptions: JsonRpcSubscriptions,
                    id: JsonNode)
-                   {.async, base.} =
-  raiseAssert "not implemented"
+                   {.async: (raises: [CancelledError]), base.} =
+  raiseAssert "not implemented "

-method close*(subscriptions: JsonRpcSubscriptions) {.async, base.} =
+method close*(subscriptions: JsonRpcSubscriptions) {.async: (raises: []), base.} =
  let ids = toSeq subscriptions.callbacks.keys
  for id in ids:
-    await subscriptions.unsubscribe(id)
+    try:
+      await subscriptions.unsubscribe(id)
+    except CatchableError as e:
+      error "JsonRpc unsubscription failed", error = e.msg, id = id

 proc getCallback(subscriptions: JsonRpcSubscriptions,
-                 id: JsonNode): ?SubscriptionCallback =
+                 id: JsonNode): ?SubscriptionCallback  {. raises:[].} =
  try:
    if not id.isNil and id in subscriptions.callbacks:
-      subscriptions.callbacks[id].some
-    else:
-      SubscriptionCallback.none
-  except KeyError:
-    SubscriptionCallback.none
+      return subscriptions.callbacks[id].some
+  except: discard

 # 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): JsonRpcSubscriptions =
+            client: RpcWebSocketClient,
+            resubscribeInterval = WsResubscribe): JsonRpcSubscriptions =
+  let subscriptions = WebSocketSubscriptions(client: client, resubscribeInterval: resubscribeInterval)

-  let subscriptions = WebSocketSubscriptions(client: client)
  proc subscriptionHandler(arguments: JsonNode) {.raises:[].} =
    let id = arguments{"subscription"} or newJString("")
    if callback =? subscriptions.getCallback(id):
-      callback(id, arguments)
+      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)
+
  subscriptions

 method subscribeBlocks(subscriptions: WebSocketSubscriptions,
                       onBlock: BlockHandler):
                      Future[JsonNode]
-                      {.async.} =
-  proc callback(id, arguments: JsonNode) {.raises: [].} =
-    if blck =? Block.fromJson(arguments{"result"}):
-      onBlock(blck)
-  let id = await subscriptions.client.eth_subscribe("newHeads")
-  subscriptions.callbacks[id] = callback
-  return id
+                      {.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

 method subscribeLogs(subscriptions: WebSocketSubscriptions,
                     filter: EventFilter,
                     onLog: LogHandler):
                    Future[JsonNode]
-                    {.async.} =
-  proc callback(id, arguments: JsonNode) =
-    if log =? Log.fromJson(arguments{"result"}):
-      onLog(log)
-  let id = await subscriptions.client.eth_subscribe("logs", filter)
-  subscriptions.callbacks[id] = callback
-  return id
+                    {.async: (raises: [SubscriptionError, CancelledError]).} =
+  proc callback(id: JsonNode, argumentsResult: ?!JsonNode) =
+    without arguments =? argumentsResult, error:
+      onLog(failure(Log, error.toErr(SubscriptionError)))
+      return
+
+    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,
                   id: JsonNode)
-                  {.async.} =
-  subscriptions.callbacks.del(id)
-  discard await subscriptions.client.eth_unsubscribe(id)
+                  {.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()

 # 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 getChanges(id: JsonNode): Future[JsonNode] {.async.} =
+  proc resubscribe(id: JsonNode): Future[?!void] {.async: (raises: [CancelledError]).} =
    try:
-      return await subscriptions.client.eth_getFilterChanges(id)
-    except CatchableError:
-      return newJArray()
+      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))

-  proc poll(id: JsonNode) {.async.} =
-    for change in await getChanges(id):
-      if callback =? subscriptions.getCallback(id):
-        callback(id, change)
+    return success()

-  proc poll {.async.} =
-    untilCancelled:
-      for id in toSeq subscriptions.callbacks.keys:
-        await poll(id)
-      await sleepAsync(pollingInterval)
+  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

  subscriptions.polling = poll()
+  asyncSpawn subscriptions.polling
  subscriptions

-method close*(subscriptions: PollingSubscriptions) {.async.} =
+method close*(subscriptions: PollingSubscriptions) {.async: (raises: []).} =
  await subscriptions.polling.cancelAndWait()
  await procCall JsonRpcSubscriptions(subscriptions).close()

 method subscribeBlocks(subscriptions: PollingSubscriptions,
                       onBlock: BlockHandler):
                      Future[JsonNode]
-                      {.async.} =
+                      {.async: (raises: [SubscriptionError, CancelledError]).} =

-  proc getBlock(hash: BlockHash) {.async.} =
+  proc getBlock(hash: BlockHash) {.async: (raises:[]).} =
    try:
      if blck =? (await subscriptions.client.eth_getBlockByHash(hash, false)):
-        onBlock(blck)
-    except CatchableError:
+        onBlock(success(blck))
+    except CancelledError:
      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

-  proc callback(id, change: JsonNode) =
    if hash =? BlockHash.fromJson(change):
      asyncSpawn getBlock(hash)

-  let id = await subscriptions.client.eth_newBlockFilter()
-  subscriptions.callbacks[id] = callback
-  return id
+  convertErrorsToSubscriptionError:
+    let id = await subscriptions.client.eth_newBlockFilter()
+    subscriptions.callbacks[id] = callback
+    subscriptions.subscriptionMapping[id] = id
+    return id

 method subscribeLogs(subscriptions: PollingSubscriptions,
                     filter: EventFilter,
                     onLog: LogHandler):
                    Future[JsonNode]
-                    {.async.} =
+                    {.async: (raises: [SubscriptionError, CancelledError]).} =

-  proc callback(id, change: JsonNode) =
-    if log =? Log.fromJson(change):
-      onLog(log)
+  proc callback(id: JsonNode, argumentsResult: ?!JsonNode) =
+    without arguments =? argumentsResult, error:
+      onLog(failure(Log, error.toErr(SubscriptionError)))
+      return

-  let id = await subscriptions.client.eth_newFilter(filter)
-  subscriptions.callbacks[id] = callback
-  return id
+    let res = Log.fromJson(arguments).mapFailure(SubscriptionError)
+    onLog(res)
+
+  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,
                   id: JsonNode)
-                  {.async.} =
-  subscriptions.callbacks.del(id)
-  discard await subscriptions.client.eth_uninstallFilter(id)
+                  {.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
--- a/ethers/signer.nim
+++ b/ethers/signer.nim
@ -1,37 +1,28 @@
 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
-  SignerError* = object of EthersError
-  EstimateGasError* = object of SignerError
-    transaction*: Transaction

-template raiseSignerError(message: string, parent: ref ProviderError = nil) =
+template raiseSignerError*(message: string, parent: ref CatchableError = nil) =
  raise newException(SignerError, message, parent)

-proc raiseEstimateGasError(
-  transaction: Transaction,
-  parent: ref ProviderError = nil
-) {.raises: [EstimateGasError] .} =
-  let e = (ref EstimateGasError)(
-    msg: "Estimate gas failed",
-    transaction: transaction,
-    parent: parent)
-  raise e
-
 template convertError(body) =
  try:
    body
-  except EthersError as error:
-    raiseSignerError(error.msg)
+  except CancelledError as error:
+    raise error
+  except ProviderError as error:
+    raise error # do not convert provider errors
  except CatchableError as error:
    raiseSignerError(error.msg)

@ -40,95 +31,89 @@ method provider*(
  doAssert false, "not implemented"

 method getAddress*(
-  signer: Signer): Future[Address]
-  {.base, async: (raises:[ProviderError, SignerError]).} =
-
+    signer: Signer
+): Future[Address] {.
+    base, async: (raises: [ProviderError, SignerError, CancelledError])
+.} =
  doAssert false, "not implemented"

 method signMessage*(
-  signer: Signer,
-  message: seq[byte]): Future[seq[byte]]
-  {.base, async: (raises: [SignerError]).} =
-
+    signer: Signer, message: seq[byte]
+): Future[seq[byte]] {.base, async: (raises: [SignerError, CancelledError]).} =
  doAssert false, "not implemented"

 method sendTransaction*(
-  signer: Signer,
-  transaction: Transaction): Future[TransactionResponse]
-  {.base, async: (raises:[SignerError]).} =
-
+    signer: Signer, transaction: Transaction
+): Future[TransactionResponse] {.
+    base, async: (raises: [SignerError, ProviderError, CancelledError])
+.} =
  doAssert false, "not implemented"

 method getGasPrice*(
-  signer: Signer): Future[UInt256]
-  {.base, async: (raises: [ProviderError, SignerError]).} =
-
+    signer: Signer
+): Future[UInt256] {.
+    base, async: (raises: [ProviderError, SignerError, CancelledError])
+.} =
  return await signer.provider.getGasPrice()

-method getTransactionCount*(
-  signer: Signer,
-  blockTag = BlockTag.latest): Future[UInt256]
-  {.base, async: (raises:[SignerError]).} =
+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: (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]).} =
-
+    signer: Signer, transaction: Transaction, blockTag = BlockTag.latest
+): Future[UInt256] {.
+    base, async: (raises: [SignerError, ProviderError, CancelledError])
+.} =
  var transaction = transaction
-  var address: Address
-
-  convertError:
-    address = await signer.getAddress
-
-  transaction.sender = some(address)
-  try:
-    return await signer.provider.estimateGas(transaction)
-  except ProviderError as e:
-    raiseEstimateGasError transaction, e
+  transaction.sender = some(await signer.getAddress())
+  return await signer.provider.estimateGas(transaction, blockTag)

 method getChainId*(
-  signer: Signer): Future[UInt256]
-  {.base, async: (raises: [ProviderError, SignerError]).} =
-
+    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]).} =
+    signer: Signer
+): Future[UInt256] {.
+    base, async: (raises: [SignerError, ProviderError, CancelledError])
+.} =
+  return await signer.getTransactionCount(BlockTag.pending)

-  var nonce = await signer.getTransactionCount(BlockTag.pending)
+template withLock*(signer: Signer, body: untyped) =
+  if signer.populateLock.isNil:
+    signer.populateLock = newAsyncLock()

-  if lastSeen =? signer.lastSeenNonce and lastSeen >= nonce:
-    nonce = (lastSeen + 1.u256)
-  signer.lastSeenNonce = some nonce
-
-  return nonce
-
-method updateNonce*(
-  signer: Signer,
-  nonce: UInt256
-) {.base, gcsafe.} =
-
-  without lastSeen =? signer.lastSeenNonce:
-    signer.lastSeenNonce = some nonce
-    return
-
-  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
+  await signer.populateLock.acquire()
+  try:
+    body
+  finally:
+    try:
+      signer.populateLock.release()
+    except AsyncLockError as e:
+      raiseSignerError e.msg, e

 method populateTransaction*(
  signer: Signer,
  transaction: Transaction): Future[Transaction]
-  {.base, async: (raises: [CancelledError, AsyncLockError, ProviderError, SignerError]).} =
+  {.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.

  var address: Address
  convertError:
@ -139,51 +124,61 @@ method populateTransaction*(
  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

-  try:
-    if transaction.sender.isNone:
-      populated.sender = some(address)
-    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())
+  if transaction.sender.isNone:
+    populated.sender = some(address)
+  if transaction.chainId.isNone:
+    populated.chainId = some(await signer.getChainId())

-    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 EstimateGasError as e:
-        signer.decreaseNonce()
-        raise e
-      except ProviderError as e:
-        signer.decreaseNonce()
-        raiseSignerError(e.msg)
+  let blk = await signer.provider.getBlock(BlockTag.latest)

-    else:
-      if transaction.nonce.isNone:
-        populated.nonce = some(await signer.getNonce())
-      if transaction.gasLimit.isNone:
-        populated.gasLimit = some(await signer.estimateGas(populated))
+  if baseFeePerGas =? blk.?baseFeePerGas:
+    let maxPriorityFeePerGas = transaction.maxPriorityFeePerGas |? (await signer.provider.getMaxPriorityFeePerGas())
+    populated.maxPriorityFeePerGas = some(maxPriorityFeePerGas)

-  finally:
-    signer.populateLock.release()
+    # 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!"

  return populated

 method cancelTransaction*(
  signer: Signer,
  tx: Transaction
-): Future[TransactionResponse] {.base, async: (raises: [SignerError]).} =
+): Future[TransactionResponse] {.base, async: (raises: [SignerError, CancelledError, ProviderError]).} =
  # cancels a transaction by sending with a 0-valued transaction to ourselves
  # with the failed tx's nonce

@ -192,7 +187,8 @@ method cancelTransaction*(
  without nonce =? tx.nonce:
    raiseSignerError "transaction must have nonce"

-  var cancelTx = Transaction(to: sender, value: 0.u256, nonce: some nonce)
-  convertError:
-    cancelTx = await signer.populateTransaction(cancelTx)
-    return await signer.sendTransaction(cancelTx)
+  withLock(signer):
+    convertError:
+      var cancelTx = Transaction(to: sender, value: 0.u256, nonce: some nonce)
+      cancelTx = await signer.populateTransaction(cancelTx)
+      return await signer.sendTransaction(cancelTx)
--- a/ethers/signers/wallet.nim
+++ b/ethers/signers/wallet.nim
@ -27,7 +27,7 @@ type Wallet* = ref object of Signer

 proc new*(_: type Wallet, privateKey: PrivateKey): Wallet =
  let publicKey = privateKey.toPublicKey()
-  let address = Address.init(publicKey.toCanonicalAddress())
+  let address = Address(publicKey.toCanonicalAddress())
  Wallet(privateKey: privateKey, publicKey: publicKey, address: address)

 proc new*(_: type Wallet, privateKey: PrivateKey, provider: Provider): Wallet =
@ -53,13 +53,13 @@ proc createRandom*(_: type Wallet): Wallet =
  result = Wallet()
  result.privateKey = PrivateKey.random(getRng()[])
  result.publicKey = result.privateKey.toPublicKey()
-  result.address = Address.init(result.publicKey.toCanonicalAddress())
+  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.init(result.publicKey.toCanonicalAddress())
+  result.address = Address(result.publicKey.toCanonicalAddress())
  result.provider = some provider

 method provider*(wallet: Wallet): Provider {.gcsafe, raises: [SignerError].} =
@ -69,7 +69,7 @@ method provider*(wallet: Wallet): Provider {.gcsafe, raises: [SignerError].} =

 method getAddress*(
  wallet: Wallet): Future[Address]
-  {.async: (raises:[ProviderError, SignerError]).} =
+  {.async: (raises:[ProviderError, SignerError, CancelledError]).} =

  return wallet.address

@ -83,10 +83,7 @@ proc signTransaction*(wallet: Wallet,
 method sendTransaction*(
  wallet: Wallet,
  transaction: Transaction): Future[TransactionResponse]
-  {.async: (raises:[SignerError]).} =
+  {.async: (raises:[SignerError, ProviderError, CancelledError]).} =

-  convertError:
-    let signed = await signTransaction(wallet, transaction)
-    if nonce =? transaction.nonce:
-      wallet.updateNonce(nonce)
-    return await provider(wallet).sendTransaction(signed)
+  let signed = await signTransaction(wallet, transaction)
+  return await provider(wallet).sendTransaction(signed)
--- a/ethers/signers/wallet/error.nim
+++ b/ethers/signers/wallet/error.nim
@ -9,5 +9,7 @@ func raiseWalletError*(message: string) {.raises: [WalletError].}=
 template convertError*(body) =
  try:
    body
+  except CancelledError as error:
+    raise error
  except CatchableError as error:
    raiseWalletError(error.msg)
--- a/ethers/signers/wallet/signing.nim
+++ b/ethers/signers/wallet/signing.nim
@ -1,11 +1,13 @@
 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 ./error
+from pkg/eth/common/eth_types import EthAddress

 type
  Transaction = ethers.Transaction
@ -24,17 +26,18 @@ func toSignableTransaction(transaction: Transaction): SignableTransaction =
    raiseWalletError "missing gas limit"

  signable.nonce = nonce.truncate(uint64)
-  signable.chainId = ChainId(chainId.truncate(uint64))
+  signable.chainId = chainId
  signable.gasLimit = GasInt(gasLimit.truncate(uint64))
-  signable.to = some EthAddress(transaction.to)
+
+  signable.to = Opt.some(EthAddress(transaction.to))
  signable.value = transaction.value
  signable.payload = transaction.data

-  if maxFee =? transaction.maxFee and
-     maxPriorityFee =? transaction.maxPriorityFee:
+  if maxFeePerGas =? transaction.maxFeePerGas and
+     maxPriorityFeePerGas =? transaction.maxPriorityFeePerGas:
    signable.txType = TxEip1559
-    signable.maxFee = GasInt(maxFee.truncate(uint64))
-    signable.maxPriorityFee = GasInt(maxPriorityFee.truncate(uint64))
+    signable.maxFeePerGas = GasInt(maxFeePerGas.truncate(uint64))
+    signable.maxPriorityFeePerGas = GasInt(maxPriorityFeePerGas.truncate(uint64))
  elif gasPrice =? transaction.gasPrice:
    signable.txType = TxLegacy
    signable.gasPrice = GasInt(gasPrice.truncate(uint64))
@ -45,21 +48,7 @@ func toSignableTransaction(transaction: Transaction): SignableTransaction =

 func sign(key: PrivateKey, transaction: SignableTransaction): seq[byte] =
  var transaction = transaction
-
-  # 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
-
+  transaction.signature = transaction.sign(key, true)
  rlp.encode(transaction)

 func sign*(key: PrivateKey, transaction: Transaction): seq[byte] =
--- a/ethers/transaction.nim
+++ b/ethers/transaction.nim
@ -15,8 +15,8 @@ type
    nonce*: ?UInt256
    chainId*: ?UInt256
    gasPrice*: ?UInt256
-    maxFee*: ?UInt256
-    maxPriorityFee*: ?UInt256
+    maxPriorityFeePerGas*: ?UInt256
+    maxFeePerGas*: ?UInt256
    gasLimit*: ?UInt256
    transactionType* {.serialize("type").}: ?TransactionType

--- a/nim.cfg
+++ b/nim.cfg
@ -1,3 +1,4 @@
 -d:"chronicles_log_level=INFO"
 -d:"json_rpc_websocket_package=websock"
 --warning[LockLevel]:off
+--warning[DotLikeOps]:off
--- a/testmodule/config.nims
+++ b/testmodule/config.nims
@ -3,3 +3,5 @@ when (NimMajor, NimMinor) >= (1, 4):
  switch("hint", "XCannotRaiseY:off")
 when (NimMajor, NimMinor, NimPatch) >= (1, 6, 11):
  switch("warning", "BareExcept:off")
+
+--define:"chronicles_enabled:off"
--- a/testmodule/hardhat.nim
+++ b/testmodule/hardhat.nim
@ -1,4 +1,4 @@
-import std/json
+import pkg/serde
 import pkg/ethers/basics

 type Deployment* = object
--- a/testmodule/helpers.nim
+++ b/testmodule/helpers.nim
@ -7,7 +7,7 @@ type
 method doRevert*(
  self: TestHelpers,
  revertReason: string
-): ?TransactionResponse {.base, contract.}
+): Confirmable {.base, contract.}

 proc new*(_: type TestHelpers, signer: Signer): TestHelpers =
  let deployment = readDeployment()
--- a/testmodule/mocks.nim
+++ b/testmodule/mocks.nim
@ -13,13 +13,13 @@ method provider*(signer: MockSigner): Provider =

 method getAddress*(
  signer: MockSigner): Future[Address]
-  {.async: (raises:[ProviderError, SignerError]).} =
+  {.async: (raises:[ProviderError, SignerError, CancelledError]).} =

  return signer.address

 method sendTransaction*(
  signer: MockSigner,
  transaction: Transaction): Future[TransactionResponse]
-  {.async: (raises:[SignerError]).} =
+  {.async: (raises:[SignerError, ProviderError, CancelledError]).} =

  signer.transactions.add(transaction)
--- a/testmodule/providers/jsonrpc/rpc_mock.nim
+++ b/testmodule/providers/jsonrpc/rpc_mock.nim
@ -0,0 +1,56 @@
+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()
--- a/testmodule/providers/jsonrpc/testConversions.nim
+++ b/testmodule/providers/jsonrpc/testConversions.nim
@ -26,8 +26,7 @@ suite "JSON Conversions":
    json["number"] = newJString("")

    let blk2 = !Block.fromJson(json)
-    check blk2.number.isSome
-    check blk2.number.get.isZero
+    check blk2.number.isNone

  test "missing block hash in Block isNone":

@ -41,7 +40,7 @@ suite "JSON Conversions":
    }

    without blk =? Block.fromJson(blkJson["result"]):
-      fail
+      unittest.fail
    check blk.hash.isNone

  test "missing block number in TransactionReceipt isNone":
@ -72,14 +71,13 @@ suite "JSON Conversions":
    }

    without receipt1 =? TransactionReceipt.fromJson(json):
-      fail
+      unittest.fail
    check receipt1.blockNumber.isNone

    json["blockNumber"] = newJString("")
    without receipt2 =? TransactionReceipt.fromJson(json):
-      fail
-    check receipt2.blockNumber.isSome
-    check receipt2.blockNumber.get.isZero
+      unittest.fail
+    check receipt2.blockNumber.isNone

  test "missing block hash in TransactionReceipt isNone":
    let json = %*{
@ -109,7 +107,7 @@ suite "JSON Conversions":
    }

    without receipt =? TransactionReceipt.fromJson(json):
-      fail
+      unittest.fail
    check receipt.blockHash.isNone

  test "correctly deserializes PastTransaction":
@ -133,8 +131,8 @@ suite "JSON Conversions":
    }

    without tx =? PastTransaction.fromJson(json):
-      fail
-    check tx.blockHash == BlockHash(array[32, byte].fromHex("0x595bffbe897e025ea2df3213c4cc52c3f3d69bc04b49011d558f1b0e70038922"))
+      unittest.fail
+    check tx.blockHash == BlockHash.fromHex("0x595bffbe897e025ea2df3213c4cc52c3f3d69bc04b49011d558f1b0e70038922")
    check tx.blockNumber == 0x22e.u256
    check tx.sender == Address.init("0xe00b677c29ff8d8fe6068530e2bc36158c54dd34").get
    check tx.gas == 0x4d4bb.u256
@ -153,7 +151,7 @@ suite "JSON Conversions":

  test "PastTransaction serializes correctly":
    let tx = PastTransaction(
-      blockHash: BlockHash(array[32, byte].fromHex("0x595bffbe897e025ea2df3213c4cc52c3f3d69bc04b49011d558f1b0e70038922")),
+      blockHash: BlockHash.fromHex("0x595bffbe897e025ea2df3213c4cc52c3f3d69bc04b49011d558f1b0e70038922"),
      blockNumber: 0x22e.u256,
      sender: Address.init("0xe00b677c29ff8d8fe6068530e2bc36158c54dd34").get,
      gas: 0x4d4bb.u256,
@ -212,7 +210,7 @@ suite "JSON Conversions":
    }

    without past =? PastTransaction.fromJson(json):
-      fail
+      unittest.fail
    check %past.toTransaction == %*{
      "to": !Address.init("0x92f09aa59dccb892a9f5406ddd9c0b98f02ea57e"),
      "data": hexToSeqByte("0x6368a471d26ff5c7f835c1a8203235e88846ce1a196d6e79df0eaedd1b8ed3deec2ae5c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000012a00000000000000000000000000000000000000000000000000000000000000"),
@ -223,3 +221,34 @@ suite "JSON Conversions":
      "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\""
--- a/testmodule/providers/jsonrpc/testErrors.nim
+++ b/testmodule/providers/jsonrpc/testErrors.nim
@ -0,0 +1,27 @@
+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]
--- a/testmodule/providers/jsonrpc/testJsonRpcProvider.nim
+++ b/testmodule/providers/jsonrpc/testJsonRpcProvider.nim
@ -1,4 +1,5 @@
-import pkg/asynctest
+import std/os
+import pkg/asynctest/chronos/unittest
 import pkg/chronos
 import pkg/ethers
 import pkg/ethers/providers/jsonrpc/conversions
@ -6,7 +7,8 @@ import pkg/stew/byteutils
 import ../../examples
 import ../../miner

-for url in ["ws://localhost:8545", "http://localhost:8545"]:
+let providerUrl = getEnv("ETHERS_TEST_PROVIDER", "localhost:8545")
+for url in ["ws://" & providerUrl, "http://"  & providerUrl]:

  suite "JsonRpcProvider (" & url & ")":

@ -28,7 +30,7 @@ for url in ["ws://localhost:8545", "http://localhost:8545"]:

    test "sends raw messages to the provider":
      let response = await provider.send("evm_mine")
-      check response == %"0x0"
+      check response == %"0"

    test "returns block number":
      let blocknumber1 = await provider.getBlockNumber()
@ -47,7 +49,7 @@ for url in ["ws://localhost:8545", "http://localhost:8545"]:
      let oldBlock = !await provider.getBlock(BlockTag.latest)
      discard await provider.send("evm_mine")
      var newBlock: Block
-      let blockHandler = proc(blck: Block) = newBlock = blck
+      let blockHandler = proc(blck: ?!Block) {.raises:[].}= newBlock = blck.value
      let subscription = await provider.subscribe(blockHandler)
      discard await provider.send("evm_mine")
      check eventually newBlock.number.isSome
@ -66,13 +68,13 @@ for url in ["ws://localhost:8545", "http://localhost:8545"]:
      check UInt256.fromHex("0x" & txResp.hash.toHex) > 0

    test "can wait for a transaction to be confirmed":
-      for confirmations in 0..3:
+      for confirmations in 1..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 - 1)
+        await provider.mineBlocks(confirmations)
        let receipt = await confirming
        check receipt.blockNumber.isSome

@ -80,6 +82,7 @@ for url in ["ws://localhost:8545", "http://localhost:8545"]:
      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
@ -95,8 +98,8 @@ for url in ["ws://localhost:8545", "http://localhost:8545"]:
      expect JsonRpcProviderError:
        discard await provider.getBlock(BlockTag.latest)
      expect JsonRpcProviderError:
-        discard await provider.subscribe(proc(_: Block) = discard)
-      expect JsonRpcSignerError:
+        discard await provider.subscribe(proc(_: ?!Block) = discard)
+      expect JsonRpcProviderError:
        discard await provider.getSigner().sendTransaction(Transaction.example)

    test "syncing":
--- a/testmodule/providers/jsonrpc/testJsonRpcSigner.nim
+++ b/testmodule/providers/jsonrpc/testJsonRpcSigner.nim
@ -1,4 +1,5 @@
-import pkg/asynctest
+import std/os
+import pkg/asynctest/chronos/unittest
 import pkg/ethers
 import pkg/stew/byteutils
 import ../../examples
@ -7,9 +8,10 @@ suite "JsonRpcSigner":

  var provider: JsonRpcProvider
  var accounts: seq[Address]
+  let providerUrl = getEnv("ETHERS_TEST_PROVIDER", "localhost:8545")

  setup:
-    provider = JsonRpcProvider.new()
+    provider = JsonRpcProvider.new("http://" & providerUrl)
    accounts = await provider.listAccounts()

  teardown:
@ -53,20 +55,27 @@ 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.gasPrice = some UInt256.example
+    transaction.maxPriorityFeePerGas = 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":
@ -82,24 +91,3 @@ 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
--- a/testmodule/providers/jsonrpc/testJsonRpcSubscriptions.nim
+++ b/testmodule/providers/jsonrpc/testJsonRpcSubscriptions.nim
@ -1,9 +1,15 @@
-import std/json
-import pkg/asynctest
+import std/os
+import std/importutils
+import pkg/asynctest/chronos/unittest
+import pkg/serde
 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":
@ -20,8 +26,8 @@ template subscriptionTests(subscriptions, client) =

  test "subscribes to new blocks":
    var latestBlock: Block
-    proc callback(blck: Block) =
-      latestBlock = blck
+    proc callback(blck: ?!Block) =
+      latestBlock = blck.value
    let subscription = await subscriptions.subscribeBlocks(callback)
    discard await client.call("evm_mine", newJArray())
    check eventually latestBlock.number.isSome
@ -31,8 +37,9 @@ template subscriptionTests(subscriptions, client) =

  test "stops listening to new blocks when unsubscribed":
    var count = 0
-    proc callback(blck: Block) =
-      inc count
+    proc callback(blck: ?!Block) =
+      if blck.isOk:
+        inc count
    let subscription = await subscriptions.subscribeBlocks(callback)
    discard await client.call("evm_mine", newJArray())
    check eventually count > 0
@ -42,10 +49,20 @@ 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) =
-      inc count
+    proc callback(blck: ?!Block) =
+      if blck.isOk:
+        inc count
    discard await subscriptions.subscribeBlocks(callback)
    discard await client.call("evm_mine", newJArray())
    check eventually count > 0
@ -62,7 +79,7 @@ suite "Web socket subscriptions":

  setup:
    client = newRpcWebSocketClient()
-    await client.connect("ws://localhost:8545")
+    await client.connect("ws://"  & getEnv("ETHERS_TEST_PROVIDER", "localhost:8545"))
    subscriptions = JsonRpcSubscriptions.new(client)
    subscriptions.start()

@ -79,7 +96,7 @@ suite "HTTP polling subscriptions":

  setup:
    client = newRpcHttpClient()
-    await client.connect("http://localhost:8545")
+    await client.connect("http://" & getEnv("ETHERS_TEST_PROVIDER", "localhost:8545"))
    subscriptions = JsonRpcSubscriptions.new(client,
                                             pollingInterval = 100.millis)
    subscriptions.start()
@ -89,3 +106,113 @@ suite "HTTP polling subscriptions":
    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
--- a/testmodule/providers/jsonrpc/testWsResubscription.nim
+++ b/testmodule/providers/jsonrpc/testWsResubscription.nim
@ -0,0 +1,56 @@
+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
--- a/testmodule/providers/testJsonRpc.nim
+++ b/testmodule/providers/testJsonRpc.nim
@ -1,6 +1,8 @@
 import ./jsonrpc/testJsonRpcProvider
 import ./jsonrpc/testJsonRpcSigner
 import ./jsonrpc/testJsonRpcSubscriptions
+import ./jsonrpc/testWsResubscription
 import ./jsonrpc/testConversions
+import ./jsonrpc/testErrors

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

 {.warning[UnusedImport]:off.}
--- a/testmodule/test.nimble
+++ b/testmodule/test.nimble
@ -3,8 +3,7 @@ author = "Nim Ethers Authors"
 description = "Tests for Nim Ethers library"
 license = "MIT"

-requires "asynctest >= 0.4.0 & < 0.5.0"
-requires "questionable >= 0.10.3 & < 0.11.0"
+requires "asynctest >= 0.5.4 & < 0.6.0"

 task test, "Run the test suite":
  exec "nimble install -d -y"
--- a/testmodule/testBlockTag.nim
+++ b/testmodule/testBlockTag.nim
@ -0,0 +1,56 @@
+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
--- a/testmodule/testContracts.nim
+++ b/testmodule/testContracts.nim
@ -1,6 +1,7 @@
-import std/json
+import pkg/serde
+import std/os
 import std/options
-import pkg/asynctest
+import pkg/asynctest/chronos/unittest
 import pkg/questionable
 import pkg/stint
 import pkg/ethers
@ -13,10 +14,11 @@ import ./mocks
 type
  TestToken = ref object of Erc20Token

-method mint(token: TestToken, holder: Address, amount: UInt256): ?TransactionResponse {.base, contract.}
+method mint(token: TestToken, holder: Address, amount: UInt256): Confirmable {.base, contract.}
 method myBalance(token: TestToken): UInt256 {.base, contract, view.}

-for url in ["ws://localhost:8545", "http://localhost:8545"]:
+let providerUrl = getEnv("ETHERS_TEST_PROVIDER", "localhost:8545")
+for url in ["ws://"  & providerUrl, "http://"  & providerUrl]:

  suite "Contracts (" & url & ")":

@ -62,7 +64,7 @@ for url in ["ws://localhost:8545", "http://localhost:8545"]:
    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 mint(token, accounts[1], 100.u256)
+      await token.mint(accounts[1], 100.u256)
      check (await balanceOf(token, accounts[1])) == 0.u256

    test "can call non-constant functions without a return type":
@ -71,24 +73,14 @@ for url in ["ws://localhost:8545", "http://localhost:8545"]:
      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 txResp = await token.mint(accounts[1], 100.u256)
-      check txResp is Confirmable
-      check txResp.isSome
+      let confirmable = await token.mint(accounts[1], 100.u256)
+      check confirmable is Confirmable
+      check confirmable.response.isSome

    test "fails to compile when function has an implementation":
      let works = compiles:
@ -115,17 +107,17 @@ for url in ["ws://localhost:8545", "http://localhost:8545"]:
      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 gaslimit":
+    test "takes custom values for nonce, gasprice and maxPriorityFeePerGas":
      let overrides = TransactionOverrides(
        nonce: some 100.u256,
-        gasPrice: some 200.u256,
+        maxPriorityFeePerGas: 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].gasPrice == overrides.gasPrice
+      check signer.transactions[0].maxPriorityFeePerGas == overrides.maxPriorityFeePerGas
      check signer.transactions[0].gasLimit == overrides.gasLimit

    test "can call functions for different block heights":
@ -140,10 +132,35 @@ for url in ["ws://localhost:8545", "http://localhost:8545"]:
      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(transfer: Transfer) =
+      proc handleTransfer(transferRes: ?!Transfer) =
+        without transfer =? transferRes, error:
+          echo error.msg
+
        transfers.add(transfer)

      let signer0 = provider.getSigner(accounts[0])
@ -165,8 +182,9 @@ for url in ["ws://localhost:8545", "http://localhost:8545"]:
    test "stops receiving events when unsubscribed":
      var transfers: seq[Transfer]

-      proc handleTransfer(transfer: Transfer) =
-        transfers.add(transfer)
+      proc handleTransfer(transferRes: ?!Transfer) =
+        if transfer =? transferRes:
+          transfers.add(transfer)

      let signer0 = provider.getSigner(accounts[0])

@ -266,3 +284,44 @@ for url in ["ws://localhost:8545", "http://localhost:8545"]:
        .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
--- a/testmodule/testCustomErrors.nim
+++ b/testmodule/testCustomErrors.nim
@ -0,0 +1,161 @@
+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])
--- a/testmodule/testEnums.nim
+++ b/testmodule/testEnums.nim
@ -1,4 +1,5 @@
-import pkg/asynctest
+import std/os
+import pkg/asynctest/chronos/unittest
 import pkg/ethers
 import pkg/serde
 import ./hardhat
@ -14,9 +15,10 @@ 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()
+    provider = JsonRpcProvider.new("http://" & providerUrl)
    snapshot = await provider.send("evm_snapshot")
    let deployment = readDeployment()
    contract = TestEnums.new(!deployment.address(TestEnums), provider)
--- a/testmodule/testErc20.nim
+++ b/testmodule/testErc20.nim
@ -1,5 +1,6 @@
-import std/json
-import pkg/asynctest
+import std/os
+import pkg/serde
+import pkg/asynctest/chronos/unittest
 import pkg/questionable
 import pkg/stint
 import pkg/ethers
@ -9,9 +10,10 @@ import ./hardhat
 type
  TestToken = ref object of Erc20Token

-method mint(token: TestToken, holder: Address, amount: UInt256): ?TransactionResponse {.base, contract.}
+method mint(token: TestToken, holder: Address, amount: UInt256): Confirmable {.base, contract.}

-for url in ["ws://localhost:8545", "http://localhost:8545"]:
+let providerUrl = getEnv("ETHERS_TEST_PROVIDER", "localhost:8545")
+for url in ["ws://" & providerUrl, "http://"  & providerUrl]:

  suite "ERC20 (" & url & ")":

--- a/testmodule/testErrorDecoding.nim
+++ b/testmodule/testErrorDecoding.nim
@ -0,0 +1,56 @@
+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
--- a/testmodule/testEvents.nim
+++ b/testmodule/testEvents.nim
@ -1,4 +1,4 @@
-import pkg/asynctest
+import pkg/asynctest/chronos/unittest
 import pkg/ethers
 import pkg/contractabi
 import ./examples
--- a/testmodule/testGasEstimation.nim
+++ b/testmodule/testGasEstimation.nim
@ -0,0 +1,77 @@
+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
--- a/testmodule/testReturns.nim
+++ b/testmodule/testReturns.nim
@ -1,4 +1,5 @@
-import pkg/asynctest
+import std/os
+import pkg/asynctest/chronos/unittest
 import pkg/ethers
 import pkg/serde
 import ./hardhat
@ -13,9 +14,10 @@ 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()
+    provider = JsonRpcProvider.new("http://" & providerUrl)
    snapshot = await provider.send("evm_snapshot")
    let deployment = readDeployment()
    contract = TestReturns.new(!deployment.address(TestReturns), provider)
@ -53,3 +55,11 @@ 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)
--- a/testmodule/testTesting.nim
+++ b/testmodule/testTesting.nim
@ -1,5 +1,6 @@
+import std/os
 import std/strformat
-import pkg/asynctest
+import pkg/asynctest/chronos/unittest
 import pkg/chronos
 import pkg/ethers
 import pkg/ethers/testing
@ -92,9 +93,10 @@ 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://127.0.0.1:8545")
+    provider = JsonRpcProvider.new("ws://" & providerUrl)
    snapshot = await provider.send("evm_snapshot")
    accounts = await provider.listAccounts()
    helpersContract = TestHelpers.new(provider.getSigner())
--- a/testmodule/testWallet.nim
+++ b/testmodule/testWallet.nim
@ -1,4 +1,5 @@
-import pkg/asynctest
+import std/os
+import pkg/asynctest/chronos/unittest
 import pkg/serde
 import pkg/stew/byteutils
 import ../ethers
@ -12,9 +13,10 @@ 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()
+    provider = JsonRpcProvider.new("http://" & providerUrl)
    snapshot = await provider.send("evm_snapshot")

  teardown:
@ -78,8 +80,8 @@ suite "Wallet":
      to: wallet.address,
      nonce: some 0.u256,
      chainId: some 31337.u256,
-      maxFee: some 2_000_000_000.u256,
-      maxPriorityFee: some 1_000_000_000.u256,
+      maxFeePerGas: some 2_000_000_000.u256,
+      maxPriorityFeePerGas: some 1_000_000_000.u256,
      gasLimit: some 21_000.u256
    )
    let signedTx = await wallet.signTransaction(tx)
@ -113,8 +115,8 @@ suite "Wallet":
    let wallet = !Wallet.new(pk_with_funds, provider)
    let overrides = TransactionOverrides(
      nonce: some 0.u256,
-      maxFee: some 1_000_000_000.u256,
-      maxPriorityFee: some 1_000_000_000.u256,
+      maxFeePerGas: some 1_000_000_000.u256,
+      maxPriorityFeePerGas: 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)
--- a/testnode/contracts/TestCustomErrors.sol
+++ b/testnode/contracts/TestCustomErrors.sol
@ -0,0 +1,58 @@
+// 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);
+  }
+}
--- a/testnode/contracts/TestGasEstimation.sol
+++ b/testnode/contracts/TestGasEstimation.sol
@ -0,0 +1,22 @@
+// 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;
+    }
+  }
+}
--- a/testnode/contracts/TestReturns.sol
+++ b/testnode/contracts/TestReturns.sol
@ -11,6 +11,9 @@ 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);
  }
--- a/testnode/deploy/testcustomerrors.js
+++ b/testnode/deploy/testcustomerrors.js
@ -0,0 +1,6 @@
+module.exports = async ({ deployments, getNamedAccounts }) => {
+  const { deployer } = await getNamedAccounts();
+  await deployments.deploy("TestCustomErrors", { from: deployer });
+};
+
+module.exports.tags = ["TestCustomErrors"];
--- a/testnode/deploy/testgasestimation.js
+++ b/testnode/deploy/testgasestimation.js
@ -0,0 +1,6 @@
+module.exports = async ({ deployments, getNamedAccounts }) => {
+  const { deployer } = await getNamedAccounts();
+  await deployments.deploy("TestGasEstimation", { from: deployer });
+};
+
+module.exports.tags = ["TestGasEstimation"];
--- a/testnode/hardhat.config.js
+++ b/testnode/hardhat.config.js
@ -2,7 +2,7 @@ require("hardhat-deploy")
 require("hardhat-deploy-ethers")

 module.exports = {
-  solidity: "0.8.11",
+  solidity: "0.8.24",
  namedAccounts: {
    deployer: { default: 0 }
  }
--- a/testnode/package-lock.json
+++ b/testnode/package-lock.json
--- a/testnode/package.json
+++ b/testnode/package.json
@ -2,10 +2,10 @@
  "name": "hardhat-project",
  "devDependencies": {
    "@openzeppelin/contracts": "^4.4.2",
-    "ethers": "^5.5.3",
-    "hardhat": "^2.8.3",
-    "hardhat-deploy": "^0.9.24",
-    "hardhat-deploy-ethers": "^0.3.0-beta.13"
+    "ethers": "^6.11.1",
+    "hardhat": "^2.22.1",
+    "hardhat-deploy": "^0.11.34",
+    "hardhat-deploy-ethers": "^0.4.1"
  },
  "scripts": {
    "start": "hardhat node --export 'deployment.json'"
Author	SHA1	Message	Date
Jacek Sieka	965b8cd752	chore: bump eth (#124 ) * recycle common transaction signature helpers * bump versions	2025-12-13 07:32:36 +01:00
Arnaud	30871c7b1d	chore: add EIP-1559 implementation for gas price (#113 ) * Add EIP-1559 implementation for gas price * Improve logs * Improve comment * Rename maxFee and maxPriorityFee to use official EIP-1559 names * Delete gas price when using EIP-1559 * Allow override maxFeePerGas * Code style * Remove useless specific EIP1559 test because Hardhart support it so all transactions are using EIP1559 by default * Restore test to check legacy transaction * Update after rebase * Call eth_maxPriorityFeePerGas and returns a manual defined maxPriorityFeePerGas as a fallback * Catch JsonRpcProviderError instead of ProviderError * Improve readability * Set none value for maxFeePerGas in case of non EIP-1559 transaction * Assign none to maxPriorityFeePerGas for non EIP-1559 transaction to avoid potential side effect in wallet signing * Remove upper bound version for stew and update contractabi	2025-05-28 16:14:01 +02:00
Mark Spanbroek	bbced46733	version 2.0.0 Changes: - supports Nim 2.0.x and 2.2.x - no longer supports Nim versions 1.6.x - better handling of async exceptions - block number can be retrieved from a block tag - workaround for hardhat websocket subscription timeouts - supports estimating gas for contract calls	2025-04-15 10:55:57 +02:00
Mark Spanbroek	c85192ae34	Make comments less confusing (I hope) Co-Authored-By: Eric <5089238+emizzle@users.noreply.github.com>	2025-04-15 10:45:52 +02:00
Mark Spanbroek	f9d115ae75	Use pending block for gas estimations	2025-04-15 10:45:52 +02:00
Mark Spanbroek	a29e86bfc8	Handle custom errors when estimating gas	2025-04-15 10:45:52 +02:00
Mark Spanbroek	4441050c3d	Move contract error handling into its own modules	2025-04-15 10:45:52 +02:00
Mark Spanbroek	e37f454761	Allow for gas estimation of contract calls	2025-04-15 10:45:52 +02:00
Mark Spanbroek	def12bfdc1	Split contract module into several parts	2025-04-15 10:45:52 +02:00
Mark Spanbroek	51aa7bc1b3	Fix asyntest update merge error	2025-04-14 16:03:45 +02:00
Mark Spanbroek	518afa3e4c	update asynctest dependency fixes segfault in Nim 2.2.2	2025-04-14 15:44:04 +02:00
Arnaud	af3d7379c8	chore: add ws resubscription for hardhat workaround (#112 ) * Move logFilters to JsonRpcSubscriptions * Add resubscribe flag * Add documentation for the resubscribe symbol * Rename the symbol for better clarity * Provide better message * Add nimbledeps to git ignore * Update wording * Update wording * Remove the ws_resubscribe flag from the config * Handle the concurrency issues when updating the logFilters and add tests * Update log filters comment * Add lock when subscribing to blocks * Remove useless private access * Fix wording * Fix try except format * Restore privateAccess because logEvents moved to JsonRpcSubscriptions * Use seconds instead of milliseconds * Remove extra dot in test label * Restore new lines * Pass the resubscribe internal in new function and remove unneeded try except * Remove ws_resubscribe default value making testing easier * Remove unneeded condition * Add new line * Fix nim syntax * Update symbol description * Log warning when the resubscription interval is more than 300 seconds * Catch errors in close method * Redefine raises for async pragma in close methods * Provide better error message	2025-04-10 10:48:41 +02:00
Arnaud	7081e6922f	Re-activate styleCheck	2025-03-18 08:42:52 +01:00
Arnaud	5d07b5dbcf	Define raises for async pragma	2025-03-18 08:12:24 +01:00
Eric	b505ef1ab8	Raise SignerError instead of propagating AsyncLockError (#109 )	2025-03-13 14:45:31 +11:00
Eric	d2b11a8657	fix(async): propagate async cancellation (#105 ) * fix(async): propagate CancelledErrors * remove CatchableError from contract macro async raises list * remove mistakenly added ContractError	2025-02-17 20:31:24 +11:00
Arnaud	26342d3e27	Update to nim 2 x (#103 ) * Update dependencies for Nim 2.x * Use refc as memory management and disable styleCheck because of testutils * Fix ambiguous import * Change Address init because eth introduced Byte20 type for Address type * use uint64 instead of init64 * Rename properties after a change in eth to be closer to the spec * Use Opt type instead of Option * Add 2.0.12 version to CI * Increment the version * Update the Nim version in CI * Update to Nim 2.0.14 * Use Nim 2.x commit hash for contractabi * Remove stable on CI because we don't want to test with Nim 2.2.x * Update Nim minimum version to 2.0.14 * fix version deps * remove fq typename * Add debug flag * Define maximumtaggedversions * Update readme --------- Co-authored-by: Eric <5089238+emizzle@users.noreply.github.com>	2025-02-14 14:18:19 +11:00
Marcin Czenko	0f98528758	adds tests for BlockTag	2024-12-10 17:41:42 +01:00
Marcin Czenko	c7c57113ce	adds number getter for BlockTags with number	2024-12-10 17:41:42 +01:00
Adam Uhlíř	037bef0256	chore: fix async raises warnings (#100 )	2024-12-09 16:22:25 +01:00
Marcin Czenko	04d3548553	version 1.0.0 This is a braking change. Subscription callbacks wrap the arguments in the Result type. Corrects the preceding commit marked with wrong version number (0.10.2).	2024-12-02 17:15:42 +01:00
Marcin Czenko	2808a05488	version 0.10.2	2024-11-28 16:15:40 +01:00
Marcin Czenko	5c93971f97	fix the test after rebasing	2024-11-28 16:08:51 +01:00
Marcin Czenko	c0cc437aa2	applies review comments	2024-11-28 16:08:51 +01:00
Marcin Czenko	4642545309	makes sure that a key on subscriptionMapping exists before trying to access it	2024-11-28 16:08:51 +01:00
Adam Uhlíř	d88e4614b1	feat: subscriptions get passed result questionable (#91 ) Co-authored-by: Eric <5089238+emizzle@users.noreply.github.com>	2024-11-28 14:48:10 +01:00
Eric	04c00e2d91	Updates non-versioned deps to their versioned counterparts (#97 ) Also bumps ethers patch version	2024-11-28 13:26:58 +11:00
Mark Spanbroek	1ae2cd4a35	version 0.10.0 This is a breaking change. Calling .confirm(0) is no longer supported; you need at least 1 confirmation.	2024-11-13 10:14:09 +01:00
Mark Spanbroek	e9d862ceca	do not crash when we cannot get block number Co-Authored-By: Eric <5089238+emizzle@users.noreply.github.com>	2024-11-13 10:09:40 +01:00
Mark Spanbroek	35aebdb46f	cleanup	2024-11-13 10:09:40 +01:00
Mark Spanbroek	f15d55f513	do not crash polling when just unsubscribed	2024-11-13 10:09:40 +01:00
Mark Spanbroek	c6a59b5187	resubscribe when error in polling	2024-11-13 10:09:40 +01:00
Mark Spanbroek	5a9895b792	disallow .confirm(0) reason: it didn't wait for any blocks to be mined, not even the block that includes the transaction.	2024-11-13 10:09:40 +01:00
Mark Spanbroek	c9275b1f6c	cleanup	2024-11-13 10:09:40 +01:00
Mark Spanbroek	40dee9b525	disable chronicles logging in tests	2024-11-13 10:09:40 +01:00
Eric	0ce6abf0fe	fix(nonce): indentation mistake after last merge (#92 ) * fix an indentation mistake after last merge * add assertion to ensure nonce is not populated * assert populated nonce is populated, not transaction	2024-11-01 16:49:06 +01:00
Adam Uhlíř	80b2ead97c	fix: block filters can be also recreated (#85 ) * fix: block filters can be also recreated * refactor: rename filter to logFilter	2024-10-30 17:26:27 +01:00
Eric	d60cedbb98	chore: bump ethers to forked deps (#89 )	2024-10-30 17:12:24 +01:00
Slava	4607817057	ci: add matrix status job (#83 )	2024-10-28 15:27:50 +02:00
Eric	6523e70eaf	fix: `items(JsonNode)` symbol not found (#87 ) * chore: export subscriptions This has a knock-on effect of nim-serde not being imported into subscriptions when JsonRpcProvider.new is called from a consumer that does not export nim-serde. * import/export serde * Replace all instances of std/json with pkg/serde	2024-10-28 14:06:20 +11:00
Eric	765379a662	fix: nonce too high (#81 ) * fix nonce issues by locking populate and send transaction Concurrent asynchronous population of transactions cause issues with nonces not being in sync with the transaction count for an account on chain. This was being mitigated by tracking a "last seen" nonce and locking inside of `populateTransaction` so that the nonce could be populated in a concurrent fashion. However, if there was an async cancellation before the transaction was sent, then the nonce would become out of sync. One solution was to decrease the nonce if a cancellation occurred. The other solution, in this commit, is simply to lock the populate and sendTransaction calls together, so that there will not be concurrent nonce discrepancies. This removes the need for "lastSeenNonce" and is overall more simple. * remove lastSeenNonce Internal nonce tracking is no longer needed since populate/sendTransaction is now locked. Even if cancelled midway, the nonce will get a refreshed value from the number of transactions from chain. * chronos v4 exception tracking * Add tests	2024-10-25 15:08:00 +11:00
Eric	b68bea9909	fix: modify unsubscribe cleanup routine and tests (#84 ) * fix: modify unsubscribe cleanup routine Ignore exceptions (other than CancelledError) if uninstallation of the filter fails. If it's the last step in the subscription 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. This includes a number of fixes: - `CancelledError` is now caught inside of `getChanges`. This was causing conditions during `subscriptions.close`, where the `CancelledError` would get consumed by the `except CatchableError`, if there was an ongoing `poll` happening at the time of close. - After creating a new filter inside of `getChanges`, the new filter is polled for changes before returning. - `getChanges` also does not swallow `CatchableError` by returning an empty array, and instead re-raises the error if it is not `filter not found`. - The tests were simplified by accessing the private fields of `PollingSubscriptions`. That way, there wasn't a race condition for the `newFilterId` counter inside of the mock. - The `MockRpcHttpServer` was simplified by keeping track of the active filters only, and invalidation simply removes the filter. The tests then only needed to rely on the fact that the filter id changed in the mapping. - Because of the above changes, we no longer needed to sleep inside of the tests, so the sleeps were removed, and the polling interval could be changed to 1ms, which not only makes the tests faster, but would further highlight any race conditions if present. * docs: rpc custom port documentation --------- Co-authored-by: Adam Uhlíř <adam@uhlir.dev>	2024-10-25 14:58:45 +11:00
Adam Uhlíř	507ac6a4cc	fix(subscriptions): filter not found recreates polling filter (#78 )	2024-10-22 15:57:25 +02:00
Adam Uhlíř	53e596e75a	fix: pinning nim-eth dependency (#77 ) Co-authored-by: Eric <5089238+emizzle@users.noreply.github.com>	2024-10-22 10:39:11 +02:00
Mark Spanbroek	e15974eb1f	version 0.9.0 This is a breaking change. Contract functions can no longer be defined to return ?TransactionResponse, use Confirmable as the return type instead.	2024-05-21 13:27:19 +02:00
Mark Spanbroek	17c6e9a8c5	test for multiple error types on a function Co-Authored-By: Eric Mastro <eric.mastro@gmail.com>	2024-05-21 13:19:24 +02:00
Mark Spanbroek	2da59a86c3	improve decoding failure messages Co-Authored-By: Eric Mastro <eric.mastro@gmail.com>	2024-05-21 13:19:24 +02:00
Mark Spanbroek	131316de08	move error conversion from TransactionResponse to Confirmable Ensures that provider no longer needs to know about error conversion, it now localized in contract.nim. Co-Authored-By: Eric Mastro <eric.mastro@gmail.com>	2024-05-21 13:19:24 +02:00
Mark Spanbroek	ab10354910	wrap transaction response into Confirmable This is a breaking change for the API of nim-ethers.	2024-05-21 13:19:24 +02:00
Mark Spanbroek	cdb230d30f	handle custom errors in confirm() calls	2024-05-21 13:19:24 +02:00
Mark Spanbroek	067e0f2eb7	readme: add description of custom errors	2024-05-21 13:19:24 +02:00
Mark Spanbroek	a6f136afdd	test custom arguments when sending transaction	2024-05-21 13:19:24 +02:00
Mark Spanbroek	9cb033e865	keep error data intact when replaying transaction	2024-05-21 13:19:24 +02:00
Mark Spanbroek	241ce6e8f3	sendTransaction raises ProviderError instead of SignerError Allows it to contain error data. It is not the signing that fails, so it makes sense to use an error type that indicates that the provider failed.	2024-05-21 13:19:24 +02:00
Mark Spanbroek	1ce9824738	EstimateGasError is a ProviderError instead of a SignerError Which allows for it to contain error data	2024-05-21 13:19:24 +02:00
Mark Spanbroek	80fcb246f6	do not export encoding and decoding functions	2024-05-21 13:19:24 +02:00
Mark Spanbroek	ce63c375f7	error messages for custom errors	2024-05-21 13:19:24 +02:00
Mark Spanbroek	955ac2d58f	abi decoding of custom error fails on trailing bytes	2024-05-21 13:19:24 +02:00
Mark Spanbroek	6d6777e8c3	test custom errors with struct arguments	2024-05-21 13:19:24 +02:00
Mark Spanbroek	9c76803302	support custom errors with arguments	2024-05-21 13:19:24 +02:00
Mark Spanbroek	74f15fca9c	support custom errors in contract calls Currently only errors without arguments	2024-05-21 13:19:24 +02:00
Mark Spanbroek	6b57e56a39	abi decoding of simple custom errors Only supports errors without arguments for now	2024-05-21 13:19:24 +02:00
Mark Spanbroek	875900b493	jsonrpc: extract error data from JSON RPC error Inspired by 'spelunk' from ethers.js: `f97b92bbb1/packages/providers/src.ts/json-rpc-provider.ts (L25)`	2024-05-21 13:19:24 +02:00
Mark Spanbroek	52d7d3dbed	jsonrpc: move error handling to separate module	2024-05-21 13:19:24 +02:00
Eric	027b5c37ad	fix: deserialize BlockTag from empty string (#73 ) Allows BlockTag to be deserialized from an empty string	2024-05-21 13:10:06 +10:00
Eric	958d7b45d1	Remove overloaded UInt256.fromJson (#74 ) * Remove overloaded UInt256.fromJson Rely instead on UInt256.fromJson from nim-serde, which deserializes an empty string for ?UInt256 into UInt256.none. Previously, empty strings were deserialized into 0.u256. BlockNumber was using this deserialization, and it appears that deserializing a missing block number from a TransactionReceipt into 0 might actually cause some issues when waiting on block confirmations. * bump version of serde * Remove "v" from version in `.nimble` * Fix nimble serde version again ¯\_(ツ)_/¯	2024-05-21 13:09:42 +10:00
Mark Spanbroek	6393546ad6	fix flaky test	2024-05-13 11:52:14 +02:00
markspanbroek	4ad5b6065e	Update dependencies (#70 ) Updates hardhat and solidity Uses personal_sign instead of eth_sign, because ethers.js also uses personal_sign, and eth_sign is now broken in hardhat (arguments are reversed). Co-authored-by: Adam Uhlíř <adam@uhlir.dev>	2024-05-13 11:51:43 +02:00
Mark Spanbroek	bcb539148a	Remove unnecessary test requirement `questionable` is already in the main nimble file	2024-03-12 09:27:18 +01:00
Mark Spanbroek	14a7485a88	Handle getter functions for public state variables Getter functions that are generated by the solidity compiler do not wrap their return value in a tuple like other functions do.	2024-03-12 09:27:18 +01:00
Mark Spanbroek	b78463a299	Refactor: handle multiple returns earlier	2024-03-12 09:27:18 +01:00
Ben Bierens	942fe034fc	Fixes isSyncing issue where object is evaluated as false (#68 )	2024-03-08 12:55:36 +01:00
Mark Spanbroek	4a57089ed2	Fix warnings	2024-03-03 06:33:52 +01:00
Mark Spanbroek	877ff82ef6	Fix: overrides when simulating transaction	2024-03-03 06:33:52 +01:00
Mark Spanbroek	af5a0f5fb4	Fix: ensure that gas estimations are done using the "pending" block	2024-02-27 09:40:20 +01:00
Mark Spanbroek	d46f5a10d3	version 0.8.0 Replaces version 0.7.2, because it includes breaking changes	2024-02-27 09:13:36 +01:00