Implement RPC calls in Jupyter/Colab

boa/integrations/jupyter/browser.py

@@ -81,17 +81,6 @@ def name(self):
         return self.identifier
 
     def fetch(self, method: str, params: Any) -> Any:
-        if method == "eth_getTransactionReceipt":
-            # we do the polling in the browser to avoid too many callbacks
-            # each callback generates currently 10px empty space in the frontend
-            timeout_ms = CALLBACK_TOKEN_TIMEOUT.total_seconds() * 1000
-            return _javascript_call(
-                "waitForTransactionReceipt",
-                params,
-                timeout_ms,
-                timeout_message=RPC_TIMEOUT_MESSAGE,
-            )
-
         return _javascript_call(
             "rpc", method, params, timeout_message=RPC_TIMEOUT_MESSAGE
         )
@@ -101,6 +90,18 @@ def fetch_multi(self, payloads: list[tuple[str, Any]]) -> list[Any]:
             "multiRpc", payloads, timeout_message=RPC_TIMEOUT_MESSAGE
         )
 
+    def wait_for_tx_receipt(self, tx_hash, timeout: float, poll_latency=0.25):
+        # we do the polling in the browser to avoid too many callbacks
+        # each callback generates currently 10px empty space in the frontend
+        timeout_ms, pool_latency_ms = timeout * 1000, poll_latency * 1000
+        return _javascript_call(
+            "waitForTransactionReceipt",
+            tx_hash,
+            timeout_ms,
+            pool_latency_ms,
+            timeout_message=RPC_TIMEOUT_MESSAGE,
+        )
+
 
 def _javascript_call(js_func: str, *args, timeout_message: str) -> Any:
     """

boa/integrations/jupyter/constants.py

@@ -1,7 +1,7 @@
 from datetime import timedelta
 
 NUL = b"\0"
-CALLBACK_TOKEN_TIMEOUT = timedelta(minutes=4)  # matches default TransactionSettings
+CALLBACK_TOKEN_TIMEOUT = timedelta(minutes=3)
 SHARED_MEMORY_LENGTH = 50 * 1024 + len(NUL)  # Size of the shared memory object
 CALLBACK_TOKEN_BYTES = 32
 ETHERS_JS_URL = "https://cdnjs.cloudflare.com/ajax/libs/ethers/6.9.0/ethers.umd.min.js"

boa/integrations/jupyter/jupyter.js

@@ -56,7 +56,7 @@
     const rpc = (method, params) => getEthersProvider().send(method, params);
 
     /** Wait until the transaction is mined */
-    const waitForTransactionReceipt = async (params, timeout, wait = 1000) => {
+    const waitForTransactionReceipt = async (params, timeout, poll_latency) => {
         try {
             const result = await rpc('eth_getTransactionReceipt', params);
             if (result) {
@@ -67,11 +67,11 @@
                 throw err;
             }
         }
-        if (timeout < wait) {
+        if (timeout < poll_latency) {
             throw new Error('Timeout waiting for transaction receipt');
         }
-        await sleep(wait);
-        return waitForTransactionReceipt(params, timeout - wait, wait);
+        await sleep(poll_latency);
+        return waitForTransactionReceipt(params, timeout - poll_latency, poll_latency);
     };
 
     /** Call multiple RPCs in sequence */

boa/network.py

@@ -1,6 +1,5 @@
 # an Environment which interacts with a real (prod or test) chain
 import contextlib
-import time
 import warnings
 from dataclasses import dataclass
 from functools import cached_property
@@ -322,24 +321,6 @@ def deploy_code(self, sender=None, gas=None, value=0, bytecode=b"", **kwargs):
 
         return create_address, deployed_bytecode
 
-    def _wait_for_tx_trace(self, tx_hash, poll_latency=0.25):
-        start = time.time()
-
-        timeout = self.tx_settings.poll_timeout
-
-        while True:
-            receipt = self._rpc.fetch("eth_getTransactionReceipt", [tx_hash])
-            if receipt is not None:
-                break
-            if time.time() + poll_latency > start + timeout:
-                raise ValueError(f"Timed out waiting for ({tx_hash})")
-            time.sleep(poll_latency)
-
-        trace = None
-        if self._tracer is not None:
-            trace = self._rpc.fetch("debug_traceTransaction", [tx_hash, self._tracer])
-        return receipt, trace
-
     @cached_property
     def _tracer(self):
         def _warn_no_tracer():
@@ -437,7 +418,13 @@ def _send_txn(self, from_, to=None, gas=None, value=None, data=None):
         # TODO real logging
         print(f"tx broadcasted: {tx_hash}")
 
-        receipt, trace = self._wait_for_tx_trace(tx_hash)
+        receipt = self._rpc.wait_for_tx_receipt(tx_hash, self.tx_settings.poll_timeout)
+
+        trace = None
+        if self._tracer is not None:
+            trace = self._rpc.fetch_uncached(
+                "debug_traceTransaction", [tx_hash, self._tracer]
+            )
 
         print(f"{tx_hash} mined in block {receipt['blockHash']}!")
 

boa/rpc.py

@@ -1,3 +1,4 @@
+import time
 from typing import Any
 from urllib.parse import urlparse
 
@@ -78,6 +79,17 @@ def fetch(self, method: str, params: Any) -> Any:
     def fetch_multi(self, payloads: list[tuple[str, Any]]) -> list[Any]:
         raise NotImplementedError
 
+    def wait_for_tx_receipt(self, tx_hash, timeout: float, poll_latency=0.25):
+        start = time.time()
+
+        while True:
+            receipt = self.fetch_uncached("eth_getTransactionReceipt", [tx_hash])
+            if receipt is not None:
+                return receipt
+            if time.time() + poll_latency > start + timeout:
+                raise ValueError(f"Timed out waiting for ({tx_hash})")
+            time.sleep(poll_latency)
+
 
 class EthereumRPC(RPC):
     def __init__(self, url: str):