eth-prototype 1.2.1b1__tar.gz → 1.3.0b1__tar.gz

{eth_prototype-1.2.1b1 → eth_prototype-1.3.0b1}/.github/workflows/test.yaml

@@ -28,6 +28,5 @@ jobs:
           cd tests/hardhat-project
           npm ci
           npx hardhat compile
-          npx hardhat node &
       - name: Test with tox
         run: tox

{eth_prototype-1.2.1b1 → eth_prototype-1.3.0b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: eth-prototype
-Version: 1.2.1b1
+Version: 1.3.0b1
 Summary: Prototype Ethereum Smart Contracts in Python
 Home-page: https://github.com/gnarvaja/eth-prototype
 Author: Guillermo M. Narvaja
@@ -32,6 +32,8 @@ Requires-Dist: gmpy2; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: web3[tester]==7.*; extra == "testing"
 Requires-Dist: boto3; extra == "testing"
+Requires-Dist: pytest-recording; extra == "testing"
+Requires-Dist: factory-boy; extra == "testing"
 
 # eth-prototype
 

{eth_prototype-1.2.1b1 → eth_prototype-1.3.0b1}/setup.cfg

@@ -47,6 +47,8 @@ testing =
 	pytest-cov
 	web3[tester]==7.*
 	boto3
+	pytest-recording
+	factory-boy
 
 [options.entry_points]
 

{eth_prototype-1.2.1b1 → eth_prototype-1.3.0b1}/src/eth_prototype.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: eth-prototype
-Version: 1.2.1b1
+Version: 1.3.0b1
 Summary: Prototype Ethereum Smart Contracts in Python
 Home-page: https://github.com/gnarvaja/eth-prototype
 Author: Guillermo M. Narvaja
@@ -32,6 +32,8 @@ Requires-Dist: gmpy2; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: web3[tester]==7.*; extra == "testing"
 Requires-Dist: boto3; extra == "testing"
+Requires-Dist: pytest-recording; extra == "testing"
+Requires-Dist: factory-boy; extra == "testing"
 
 # eth-prototype
 

{eth_prototype-1.2.1b1 → eth_prototype-1.3.0b1}/src/eth_prototype.egg-info/SOURCES.txt

@@ -36,6 +36,11 @@ src/ethproto/defender_relay.py
 src/ethproto/w3wrappers.py
 src/ethproto/wadray.py
 src/ethproto/wrappers.py
+src/ethproto/test_utils/__init__.py
+src/ethproto/test_utils/factories.py
+src/ethproto/test_utils/hardhat.py
+src/ethproto/test_utils/vcr_utils.py
+tests/__init__.py
 tests/conftest.py
 tests/test_aa_bundler.py
 tests/test_build_artifacts.py
@@ -44,6 +49,7 @@ tests/test_defender.py
 tests/test_time_control.py
 tests/test_w3.py
 tests/test_wadray.py
+tests/cassettes/test_aa_bundler/test_build_user_operation.yaml
 tests/hardhat-project/README.md
 tests/hardhat-project/hardhat.config.js
 tests/hardhat-project/package-lock.json

{eth_prototype-1.2.1b1 → eth_prototype-1.3.0b1}/src/eth_prototype.egg-info/requires.txt

@@ -19,6 +19,8 @@ gmpy2
 pytest-cov
 web3[tester]==7.*
 boto3
+pytest-recording
+factory-boy
 
 [web3]
 web3==7.*

eth_prototype-1.3.0b1/src/ethproto/aa_bundler.py

@@ -0,0 +1,411 @@
+import random
+from collections import defaultdict
+from dataclasses import dataclass, replace
+from enum import Enum
+from threading import local
+from warnings import warn
+
+from environs import Env
+from eth_abi import encode
+from eth_account import Account
+from eth_account.messages import encode_defunct
+from eth_typing import HexAddress
+from eth_utils import add_0x_prefix, function_signature_to_4byte_selector
+from hexbytes import HexBytes
+from web3 import Web3
+from web3.constants import ADDRESS_ZERO
+
+from .contracts import RevertError
+
+env = Env()
+
+AA_BUNDLER_URL = env.str("AA_BUNDLER_URL", env.str("WEB3_PROVIDER_URI", "http://localhost:8545"))
+AA_BUNDLER_SENDER = env.str("AA_BUNDLER_SENDER", None)
+AA_BUNDLER_ENTRYPOINT = env.str("AA_BUNDLER_ENTRYPOINT", "0x0000000071727De22E5E9d8BAf0edAc6f37da032")
+AA_BUNDLER_EXECUTOR_PK = env.str("AA_BUNDLER_EXECUTOR_PK", None)
+AA_BUNDLER_PROVIDER = env.str("AA_BUNDLER_PROVIDER", "alchemy")
+AA_BUNDLER_GAS_LIMIT_FACTOR = env.float("AA_BUNDLER_GAS_LIMIT_FACTOR", 1)
+AA_BUNDLER_PRIORITY_GAS_PRICE_FACTOR = env.float("AA_BUNDLER_PRIORITY_GAS_PRICE_FACTOR", 1)
+AA_BUNDLER_BASE_GAS_PRICE_FACTOR = env.float("AA_BUNDLER_BASE_GAS_PRICE_FACTOR", 1)
+AA_BUNDLER_VERIFICATION_GAS_FACTOR = env.float("AA_BUNDLER_VERIFICATION_GAS_FACTOR", 1)
+
+NonceMode = Enum(
+    "NonceMode",
+    [
+        "RANDOM_KEY",  # first time initializes a random key and increments nonce locally with calling the blockchain
+        "RANDOM_KEY_EVERYTIME",  # initializes a random key every time and increments nonce locally
+        "FIXED_KEY_LOCAL_NONCE",  # uses a fixed key, keeps nonce locally and fetches the nonce when receiving
+        # 'AA25 invalid account nonce'
+        "FIXED_KEY_FETCH_ALWAYS",  # uses a fixed key, always fetches unless received as parameter
+    ],
+)
+
+AA_BUNDLER_NONCE_MODE = env.enum("AA_BUNDLER_NONCE_MODE", default="FIXED_KEY_LOCAL_NONCE", type=NonceMode)
+AA_BUNDLER_NONCE_KEY = env.int("AA_BUNDLER_NONCE_KEY", 0)
+AA_BUNDLER_MAX_GETNONCE_RETRIES = env.int("AA_BUNDLER_MAX_GETNONCE_RETRIES", 3)
+
+
+GET_NONCE_ABI = [
+    {
+        "inputs": [
+            {"internalType": "address", "name": "sender", "type": "address"},
+            {"internalType": "uint192", "name": "key", "type": "uint192"},
+        ],
+        "name": "getNonce",
+        "outputs": [{"internalType": "uint256", "name": "nonce", "type": "uint256"}],
+        "stateMutability": "view",
+        "type": "function",
+    }
+]
+
+NONCE_CACHE = defaultdict(lambda: 0)
+RANDOM_NONCE_KEY = local()
+
+DUMMY_SIGNATURE = HexBytes(
+    "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007"
+    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c"
+)
+
+
+@dataclass(frozen=True)
+class UserOpEstimation:
+    """eth_estimateUserOperationGas response"""
+
+    pre_verification_gas: int
+    verification_gas_limit: int
+    call_gas_limit: int
+    paymaster_verification_gas_limit: int
+
+
+@dataclass(frozen=True)
+class GasPrice:
+    max_priority_fee_per_gas: int
+    max_fee_per_gas: int
+
+
+@dataclass(frozen=True)
+class Tx:
+    target: HexAddress
+    data: HexBytes
+    value: int
+
+    nonce_key: HexBytes = None
+    nonce: int = None
+    from_: HexAddress = ADDRESS_ZERO
+    chain_id: int = None
+
+    def as_execute_args(self):
+        return [self.target, self.value, self.data]
+
+
+@dataclass(frozen=True)
+class UserOperation:
+    EXECUTE_ARG_TYPES = ["address", "uint256", "bytes"]
+    EXECUTE_SELECTOR = function_signature_to_4byte_selector(f"execute({','.join(EXECUTE_ARG_TYPES)})")
+
+    sender: HexBytes
+    nonce: int
+    call_data: HexBytes
+
+    max_fee_per_gas: int = 0
+    max_priority_fee_per_gas: int = 0
+
+    call_gas_limit: int = 0
+    verification_gas_limit: int = 0
+    pre_verification_gas: int = 0
+
+    signature: HexBytes = DUMMY_SIGNATURE
+
+    init_code: HexBytes = HexBytes("0x")
+    paymaster_and_data: HexBytes = HexBytes("0x")
+
+    @classmethod
+    def from_tx(cls, tx: Tx, nonce):
+        return cls(
+            sender=get_sender(tx),
+            nonce=nonce,
+            call_data=add_0x_prefix(
+                (cls.EXECUTE_SELECTOR + encode(cls.EXECUTE_ARG_TYPES, tx.as_execute_args())).hex()
+            ),
+        )
+
+    def as_reduced_dict(self):
+        return {
+            "sender": self.sender,
+            "nonce": "0x%x" % self.nonce,
+            "callData": self.call_data,
+            "signature": add_0x_prefix(self.signature.hex()),
+        }
+
+    def as_dict(self):
+        return {
+            "sender": self.sender,
+            "nonce": "0x%x" % self.nonce,
+            "callData": self.call_data,
+            "callGasLimit": "0x%x" % self.call_gas_limit,
+            "verificationGasLimit": "0x%x" % self.verification_gas_limit,
+            "preVerificationGas": "0x%x" % self.pre_verification_gas,
+            "maxPriorityFeePerGas": "0x%x" % self.max_priority_fee_per_gas,
+            "maxFeePerGas": "0x%x" % self.max_fee_per_gas,
+            "signature": add_0x_prefix(self.signature.hex()),
+        }
+
+    def add_estimation(self, estimation: UserOpEstimation) -> "UserOperation":
+        return replace(
+            self,
+            call_gas_limit=estimation.call_gas_limit,
+            verification_gas_limit=estimation.verification_gas_limit,
+            pre_verification_gas=estimation.pre_verification_gas,
+        )
+
+    def add_gas_price(self, gas_price: GasPrice) -> "UserOperation":
+        return replace(
+            self,
+            max_priority_fee_per_gas=gas_price.max_priority_fee_per_gas,
+            max_fee_per_gas=gas_price.max_fee_per_gas,
+        )
+
+    def sign(self, private_key: HexBytes, chain_id, entrypoint) -> "UserOperation":
+        signature = Account.sign_message(
+            encode_defunct(
+                hexstr=PackedUserOperation.from_user_operation(self)
+                .hash_full(chain_id=chain_id, entrypoint=entrypoint)
+                .hex()
+            ),
+            private_key,
+        )
+        return replace(self, signature=signature.signature)
+
+
+@dataclass(frozen=True)
+class PackedUserOperation:
+    sender: HexBytes
+    nonce: int
+    call_data: HexBytes
+
+    account_gas_limits: HexBytes
+    pre_verification_gas: int
+    gas_fees: HexBytes
+
+    init_code: HexBytes = HexBytes("0x")
+    paymaster_and_data: HexBytes = HexBytes("0x")
+    signature: HexBytes = HexBytes("0x")
+
+    @classmethod
+    def from_user_operation(cls, user_operation: UserOperation):
+        return cls(
+            sender=user_operation.sender,
+            nonce=user_operation.nonce,
+            call_data=user_operation.call_data,
+            account_gas_limits=pack_two(user_operation.verification_gas_limit, user_operation.call_gas_limit),
+            pre_verification_gas=user_operation.pre_verification_gas,
+            gas_fees=pack_two(user_operation.max_priority_fee_per_gas, user_operation.max_fee_per_gas),
+            init_code=user_operation.init_code,
+            paymaster_and_data=user_operation.paymaster_and_data,
+            signature=user_operation.signature,
+        )
+
+    def hash(self):
+        # https://github.com/eth-infinitism/account-abstraction/blob/develop/contracts/core/UserOperationLib.sol#L54
+        hash_init_code = Web3.solidity_keccak(["bytes"], [self.init_code])
+        hash_call_data = Web3.solidity_keccak(["bytes"], [self.call_data])
+        hash_paymaster_and_data = Web3.solidity_keccak(["bytes"], [self.paymaster_and_data])
+        return Web3.keccak(
+            hexstr=encode(
+                ["address", "uint256", "bytes32", "bytes32", "bytes32", "uint256", "bytes32", "bytes32"],
+                [
+                    self.sender,
+                    self.nonce,
+                    hash_init_code,
+                    hash_call_data,
+                    HexBytes(self.account_gas_limits),
+                    self.pre_verification_gas,
+                    HexBytes(self.gas_fees),
+                    hash_paymaster_and_data,
+                ],
+            ).hex()
+        )
+
+    def hash_full(self, chain_id, entrypoint):
+        return Web3.keccak(
+            hexstr=encode(
+                ["bytes32", "address", "uint256"],
+                [self.hash(), entrypoint, chain_id],
+            ).hex()
+        )
+
+
+def pack_two(a, b):
+    a = HexBytes(a).hex()
+    b = HexBytes(b).hex()
+    return "0x" + a.zfill(32) + b.zfill(32)
+
+
+def _to_uint(x):
+    if isinstance(x, str):
+        return int(x, 16)
+    elif isinstance(x, int):
+        return x
+    raise RuntimeError(f"Invalid int value {x}")
+
+
+def make_nonce(nonce_key, nonce):
+    nonce_key = _to_uint(nonce_key)
+    nonce = _to_uint(nonce)
+    return (nonce_key << 64) | nonce
+
+
+def fetch_nonce(w3, account, entrypoint, nonce_key):
+    ep = w3.eth.contract(abi=GET_NONCE_ABI, address=entrypoint)
+    return ep.functions.getNonce(account, nonce_key).call()
+
+
+def get_random_nonce_key(force=False):
+    if force or getattr(RANDOM_NONCE_KEY, "key", None) is None:
+        RANDOM_NONCE_KEY.key = random.randint(1, 2**192 - 1)
+    return RANDOM_NONCE_KEY.key
+
+
+def consume_nonce(nonce_key, nonce):
+    NONCE_CACHE[nonce_key] = max(NONCE_CACHE[nonce_key], nonce + 1)
+
+
+def check_nonce_error(resp, retry_nonce):
+    """Returns the next nonce if resp contains a nonce error and retries weren't exhausted
+    Raises RevertError otherwise
+    """
+    if "AA25" in resp["error"]["message"] and AA_BUNDLER_MAX_GETNONCE_RETRIES > 0:
+        # Retry fetching the nonce
+        if retry_nonce == AA_BUNDLER_MAX_GETNONCE_RETRIES:
+            raise RevertError(resp["error"]["message"])
+        warn(f'{resp["error"]["message"]} error, I will retry fetching the nonce')
+        return (retry_nonce or 0) + 1
+    else:
+        raise RevertError(resp["error"]["message"])
+
+
+def get_sender(tx):
+    if tx.from_ == ADDRESS_ZERO:
+        if AA_BUNDLER_SENDER is None:
+            raise RuntimeError("Must define AA_BUNDLER_SENDER or send 'from' in the TX")
+        return AA_BUNDLER_SENDER
+    else:
+        return tx.from_
+
+
+class Bundler:
+    def __init__(
+        self,
+        w3: Web3,
+        bundler_url: str = AA_BUNDLER_URL,
+        bundler_type: str = AA_BUNDLER_PROVIDER,
+        entrypoint: HexAddress = AA_BUNDLER_ENTRYPOINT,
+        nonce_mode: NonceMode = AA_BUNDLER_NONCE_MODE,
+        fixed_nonce_key: int = AA_BUNDLER_NONCE_KEY,
+        verification_gas_factor: float = AA_BUNDLER_VERIFICATION_GAS_FACTOR,
+        gas_limit_factor: float = AA_BUNDLER_GAS_LIMIT_FACTOR,
+        priority_gas_price_factor: float = AA_BUNDLER_PRIORITY_GAS_PRICE_FACTOR,
+        base_gas_price_factor: float = AA_BUNDLER_BASE_GAS_PRICE_FACTOR,
+        executor_pk: HexBytes = AA_BUNDLER_EXECUTOR_PK,
+    ):
+        self.w3 = w3
+        self.bundler = Web3(Web3.HTTPProvider(bundler_url), middleware=[])
+        self.bundler_type = bundler_type
+        self.entrypoint = entrypoint
+        self.nonce_mode = nonce_mode
+        self.fixed_nonce_key = fixed_nonce_key
+        self.verification_gas_factor = verification_gas_factor
+        self.gas_limit_factor = gas_limit_factor
+        self.priority_gas_price_factor = priority_gas_price_factor
+        self.base_gas_price_factor = base_gas_price_factor
+        self.executor_pk = executor_pk
+
+    def get_nonce_and_key(self, tx: Tx, fetch=False):
+        nonce_key = tx.nonce_key
+        nonce = tx.nonce
+
+        if nonce_key is None:
+            if self.nonce_mode == NonceMode.RANDOM_KEY:
+                nonce_key = get_random_nonce_key()
+            elif self.nonce_mode == NonceMode.RANDOM_KEY_EVERYTIME:
+                nonce_key = get_random_nonce_key(force=True)
+            else:
+                nonce_key = self.fixed_nonce_key
+
+        if nonce is None:
+            if fetch or self.nonce_mode == NonceMode.FIXED_KEY_FETCH_ALWAYS:
+                nonce = fetch_nonce(self.w3, get_sender(tx), self.entrypoint, nonce_key)
+            else:
+                nonce = NONCE_CACHE[nonce_key]
+        return nonce_key, nonce
+
+    def get_base_fee(self):
+        blk = self.w3.eth.get_block("latest")
+        return int(_to_uint(blk["baseFeePerGas"]) * self.base_gas_price_factor)
+
+    def estimate_user_operation_gas(self, user_operation: UserOperation) -> UserOpEstimation:
+        resp = self.bundler.provider.make_request(
+            "eth_estimateUserOperationGas", [user_operation.as_reduced_dict(), self.entrypoint]
+        )
+        if "error" in resp:
+            raise RevertError(resp["error"]["message"])
+
+        paymaster_verification_gas_limit = resp["result"].get("paymasterVerificationGasLimit", "0x00")
+        return UserOpEstimation(
+            pre_verification_gas=int(resp["result"].get("preVerificationGas", "0x00"), 16),
+            verification_gas_limit=int(
+                int(resp["result"].get("verificationGasLimit", "0x00"), 16) * self.verification_gas_factor
+            ),
+            call_gas_limit=int(int(resp["result"].get("callGasLimit", "0x00"), 16) * self.gas_limit_factor),
+            paymaster_verification_gas_limit=(
+                int(paymaster_verification_gas_limit, 16)
+                if paymaster_verification_gas_limit is not None
+                else 0
+            ),
+        )
+
+    def alchemy_gas_price(self):
+        resp = self.bundler.provider.make_request("rundler_maxPriorityFeePerGas", [])
+        if "error" in resp:
+            raise RevertError(resp["error"]["message"])
+        max_priority_fee_per_gas = int(int(resp["result"], 16) * self.priority_gas_price_factor)
+        max_fee_per_gas = max_priority_fee_per_gas + self.get_base_fee()
+
+        return GasPrice(max_priority_fee_per_gas=max_priority_fee_per_gas, max_fee_per_gas=max_fee_per_gas)
+
+    def build_user_operation(self, tx: Tx, retry_nonce=None) -> UserOperation:
+        nonce_key, nonce = self.get_nonce_and_key(tx, fetch=retry_nonce is not None)
+        # Consume the nonce, even if the userop may fail later
+        consume_nonce(nonce_key, nonce)
+
+        user_operation = UserOperation.from_tx(tx, make_nonce(nonce_key, nonce))
+        estimation = self.estimate_user_operation_gas(user_operation)
+
+        user_operation = user_operation.add_estimation(estimation)
+
+        if self.bundler_type == "alchemy":
+            gas_price = self.alchemy_gas_price()
+            user_operation = user_operation.add_gas_price(gas_price)
+
+        elif self.bundler_type == "generic":
+            # At the moment generic just prices the gas at 0
+            pass
+
+        else:
+            warn(f"Unknown bundler_type: {self.bundler_type}")
+
+        return user_operation
+
+    def send_transaction(self, tx: Tx, retry_nonce=None):
+        user_operation = self.build_user_operation(tx, retry_nonce).sign(
+            self.executor_pk, tx.chain_id, self.entrypoint
+        )
+
+        resp = self.bundler.provider.make_request(
+            "eth_sendUserOperation", [user_operation.as_dict(), self.entrypoint]
+        )
+        if "error" in resp:
+            next_nonce = check_nonce_error(resp, retry_nonce)
+            return self.send_transaction(tx, retry_nonce=next_nonce)
+
+        return {"userOpHash": resp["result"]}

eth_prototype-1.3.0b1/src/ethproto/test_utils/factories.py

@@ -0,0 +1,70 @@
+from random import randint
+
+import factory
+import faker
+from eth_abi import encode
+from eth_typing import HexAddress
+from eth_utils import function_signature_to_4byte_selector, to_checksum_address
+from faker.providers import BaseProvider
+from hexbytes import HexBytes
+from web3.constants import ADDRESS_ZERO
+
+from ethproto import aa_bundler
+
+
+class EthProvider(BaseProvider):
+    """
+    A Provider for Ethereum related data
+    >>> from faker import Faker
+    >>> fake = Faker()
+    >>> fake.add_provider(EthProvider)
+    """
+
+    def eth_address(self):
+        ret = hex(randint(0, 2**160 - 1))
+        if len(ret) < 42:
+            ret = "0x" + "0" * (42 - len(ret)) + ret[2:]
+        return to_checksum_address(ret)
+
+    def eth_hash(self):
+        ret = hex(randint(0, 2**256 - 1))
+        if len(ret) < 66:
+            return "0x" + "0" * (66 - len(ret)) + ret[2:]
+        return ret
+
+
+fake = faker.Faker()
+fake.add_provider(EthProvider)
+factory.Faker.add_provider(EthProvider)
+
+
+class Tx(factory.Factory):
+    class Meta:
+        model = aa_bundler.Tx
+
+    target = factory.Faker("eth_address")
+    data = factory.LazyAttribute(
+        lambda _: (
+            function_signature_to_4byte_selector("balanceOf(address)")
+            + encode(["address"], [fake.eth_address()])
+        )
+    )
+    value = 0
+
+    nonce_key: HexBytes = None
+    nonce: int = None
+    from_: HexAddress = ADDRESS_ZERO
+    chain_id: int = None
+
+
+class UserOperation(factory.Factory):
+    class Meta:
+        model = aa_bundler.UserOperation
+
+    nonce = factory.Faker("random_int", min=0, max=2**256 - 1)
+
+    @classmethod
+    def _create(cls, model_class, *args, **kwargs):
+        tx = Tx(from_=kwargs.pop("from_", fake.eth_address()))
+        nonce = kwargs.pop("nonce")
+        return model_class.from_tx(tx, nonce)

eth_prototype-1.3.0b1/src/ethproto/test_utils/hardhat.py

@@ -0,0 +1,71 @@
+import os
+import signal
+import subprocess
+import sys
+import time
+
+import requests
+
+
+def hardhat_node(hardhat_project_path, hostname="127.0.0.1", port=8545):
+    """Starts the hardhat node on the given path and returns a function to stop it"""
+    provider_uri = f"http://{hostname}:{port}"
+
+    # Compile the Hardhat project
+    compile_process = subprocess.run(
+        ["npx", "hardhat", "compile"], cwd=hardhat_project_path, capture_output=True, text=True
+    )
+    if compile_process.returncode != 0:
+        raise RuntimeError(f"Hardhat compilation failed: {compile_process.stderr}")
+
+    # Start the Hardhat node
+    node_process = subprocess.Popen(
+        ["npx", "hardhat", "node"],
+        start_new_session=True,
+        cwd=hardhat_project_path,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        close_fds=True,
+        text=True,
+    )
+
+    # Wait for the node to be ready by checking eth_chainId
+    def is_node_ready():
+        try:
+            response = requests.post(
+                provider_uri,
+                json={"jsonrpc": "2.0", "method": "eth_chainId", "params": [], "id": 1},
+                timeout=1,
+            )
+            return response.status_code == 200
+        except Exception:
+            return False
+
+    def terminate_node():
+        node_process.terminate()
+        os.killpg(os.getpgid(node_process.pid), signal.SIGTERM)
+        try:
+            node_process.communicate(timeout=5)
+        except subprocess.TimeoutExpired:
+            print("Hardhat node did not terminate in time, killing the whole process group", file=sys.stderr)
+            os.killpg(os.getpgid(node_process.pid), signal.SIGKILL)
+
+    # Retry mechanism to check node readiness
+    max_attempts = 20
+    for _ in range(max_attempts):
+        if is_node_ready():
+            break
+        time.sleep(0.5)
+    else:
+        terminate_node()
+        raise RuntimeError("Hardhat node did not become ready in time")
+
+    # Did we actually connect to our process, or did it fail because another node was already started?
+    try:
+        _, stderr = node_process.communicate(timeout=2)
+        raise RuntimeError(f"Hardhat node process exited with code {node_process.returncode}: {stderr}")
+    except subprocess.TimeoutExpired:
+        # We connected to our process, everything is good
+        pass
+
+    return terminate_node

eth_prototype-1.3.0b1/src/ethproto/test_utils/vcr_utils.py

@@ -0,0 +1,23 @@
+import json
+from urllib.parse import urlparse, urlunparse
+
+
+def before_record_request(request):
+    # Scrub the path and query string, which might contain credentials (alchemy, infura)
+    scheme, netloc, path, params, query, fragment = urlparse(request.uri)
+    request.uri = urlunparse((scheme, netloc, "", params, "", fragment))
+
+    # Other common security-related concerns
+    request.headers.pop("Authorization", None)
+
+    return request
+
+
+def json_rpc_matcher(r1, r2):
+    assert r1.headers["Content-Type"] == r2.headers["Content-Type"] == "application/json"
+    r1_body = json.loads(r1.body)
+    r2_body = json.loads(r2.body)
+
+    assert r1_body["jsonrpc"] == r2_body["jsonrpc"] == "2.0"
+    assert r1_body["method"] == r2_body["method"]
+    assert r1_body["params"] == r2_body["params"]