eth-prototype 1.2.1__py3-none-any.whl → 1.3.0b1__py3-none-any.whl

{eth_prototype-1.2.1.dist-info → eth_prototype-1.3.0b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: eth-prototype
-Version: 1.2.1
+Version: 1.3.0b1
 Summary: Prototype Ethereum Smart Contracts in Python
 Home-page: https://github.com/gnarvaja/eth-prototype
 Author: Guillermo M. Narvaja
@@ -19,6 +19,8 @@ Requires-Dist: environs
 Requires-Dist: requests
 Requires-Dist: hexbytes
 Requires-Dist: importlib-metadata; python_version < "3.8"
+Provides-Extra: web3
+Requires-Dist: web3==7.*; extra == "web3"
 Provides-Extra: defender
 Requires-Dist: boto3; extra == "defender"
 Provides-Extra: gmpy2
@@ -30,8 +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"
-Provides-Extra: web3
-Requires-Dist: web3==7.*; extra == "web3"
+Requires-Dist: pytest-recording; extra == "testing"
+Requires-Dist: factory-boy; extra == "testing"
 
 # eth-prototype
 

eth_prototype-1.3.0b1.dist-info/RECORD

@@ -0,0 +1,18 @@
+ethproto/__init__.py,sha256=YWkAFysBp4tZjLWWB2FFmp5yG23pUYhQvgQW9b3soXs,579
+ethproto/aa_bundler.py,sha256=vVEiorWPpLq7ev8-wKUQ8fpgDZpaOz9LGlKGNFH0faU,14987
+ethproto/build_artifacts.py,sha256=xwCd5hJUHP82IA-y3sSfX6fV15kjCGtV19RxNRcoor0,5441
+ethproto/contracts.py,sha256=rNVbCK1hURy7lWKhzSdXgVWo3wx9O_Ghk-6PfgOsRNk,18662
+ethproto/defender_relay.py,sha256=05A8TfRZwiBhCpo924Pf9CjfKSir2Wvgg1p_asFxJbw,1777
+ethproto/w3wrappers.py,sha256=4ZEnJFrc8bV1qHG4dNdom4FL1gEUhgoJORY6cGzlJDk,21549
+ethproto/wadray.py,sha256=JBsu5KcyU9k70bDK03T2IY6qPVFO30WbYPhwrAHdXao,8262
+ethproto/wrappers.py,sha256=9qDwRDOXw3wquzvGfIsub-VPWm98GBWP7dHLFOUPWzg,17307
+ethproto/test_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ethproto/test_utils/factories.py,sha256=G8DnUDG_yThRxMTCkymzcjm9lR_ni0_ZmTsb3sEfIdI,1805
+ethproto/test_utils/hardhat.py,sha256=HzTqIznu6zVd_-doL96ftFJ235ktDCQen1QDQbNuwfM,2361
+ethproto/test_utils/vcr_utils.py,sha256=1FH2sgJlElSjWkJLuO3C7E2J-4HKyFvjAqkCnGRZJyk,797
+eth_prototype-1.3.0b1.dist-info/AUTHORS.rst,sha256=Ui-05yYXtDZxna6o1yNcfdm8Jt68UIDQ01osiLxlYlU,95
+eth_prototype-1.3.0b1.dist-info/LICENSE.txt,sha256=U_Q6_nDYDwZPIuhttHi37hXZ2qU2-HlV2geo9hzHXFw,1087
+eth_prototype-1.3.0b1.dist-info/METADATA,sha256=Ipe-jiFcOwqo89hto7kwoZ52UetWAmwC7i8y_5km0_g,2583
+eth_prototype-1.3.0b1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+eth_prototype-1.3.0b1.dist-info/top_level.txt,sha256=Dl0X7m6N1hxeo4JpGpSNqWC2gtsN0731g-DL1J0mpjc,9
+eth_prototype-1.3.0b1.dist-info/RECORD,,

{eth_prototype-1.2.1.dist-info → eth_prototype-1.3.0b1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ethproto/aa_bundler.py

@@ -1,5 +1,6 @@
 import random
 from collections import defaultdict
+from dataclasses import dataclass, replace
 from enum import Enum
 from threading import local
 from warnings import warn
@@ -8,7 +9,8 @@ from environs import Env
 from eth_abi import encode
 from eth_account import Account
 from eth_account.messages import encode_defunct
-from eth_utils import add_0x_prefix
+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
@@ -17,6 +19,7 @@ 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)
@@ -30,6 +33,7 @@ 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
@@ -57,6 +61,179 @@ GET_NONCE_ABI = [
 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()
@@ -72,98 +249,23 @@ def _to_uint(x):
     raise RuntimeError(f"Invalid int value {x}")
 
 
-def apply_factor(x, factor):
-    return int(_to_uint(x) * factor)
-
-
-def pack_user_operation(user_operation):
-    # https://github.com/eth-infinitism/account-abstraction/blob/develop/contracts/interfaces/PackedUserOperation.sol
-    return {
-        "sender": user_operation["sender"],
-        "nonce": _to_uint(user_operation["nonce"]),
-        "initCode": "0x",
-        "callData": user_operation["callData"],
-        "accountGasLimits": pack_two(user_operation["verificationGasLimit"], user_operation["callGasLimit"]),
-        "preVerificationGas": _to_uint(user_operation["preVerificationGas"]),
-        "gasFees": pack_two(user_operation["maxPriorityFeePerGas"], user_operation["maxFeePerGas"]),
-        "paymasterAndData": "0x",
-        "signature": "0x",
-    }
-
-
-def hash_packed_user_operation_only(packed_user_op):
-    # https://github.com/eth-infinitism/account-abstraction/blob/develop/contracts/core/UserOperationLib.sol#L54
-    hash_init_code = Web3.solidity_keccak(["bytes"], [packed_user_op["initCode"]])
-    hash_call_data = Web3.solidity_keccak(["bytes"], [packed_user_op["callData"]])
-    hash_paymaster_and_data = Web3.solidity_keccak(["bytes"], [packed_user_op["paymasterAndData"]])
-    return Web3.keccak(
-        hexstr=encode(
-            ["address", "uint256", "bytes32", "bytes32", "bytes32", "uint256", "bytes32", "bytes32"],
-            [
-                packed_user_op["sender"],
-                packed_user_op["nonce"],
-                hash_init_code,
-                hash_call_data,
-                HexBytes(packed_user_op["accountGasLimits"]),
-                packed_user_op["preVerificationGas"],
-                HexBytes(packed_user_op["gasFees"]),
-                hash_paymaster_and_data,
-            ],
-        ).hex()
-    )
-
-
-def hash_packed_user_operation(packed_user_op, chain_id, entry_point):
-    return Web3.keccak(
-        hexstr=encode(
-            ["bytes32", "address", "uint256"],
-            [hash_packed_user_operation_only(packed_user_op), entry_point, chain_id],
-        ).hex()
-    )
-
-
-def sign_user_operation(private_key, user_operation, chain_id, entry_point):
-    packed_user_op = pack_user_operation(user_operation)
-    hash = hash_packed_user_operation(packed_user_op, chain_id, entry_point)
-    signature = Account.sign_message(encode_defunct(hexstr=hash.hex()), private_key)
-    return signature.signature
-
-
 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, entry_point, nonce_key):
-    ep = w3.eth.contract(abi=GET_NONCE_ABI, address=entry_point)
+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():
-    if getattr(RANDOM_NONCE_KEY, "key", None) is None:
+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 get_nonce_and_key(w3, tx, nonce_mode, entry_point=AA_BUNDLER_ENTRYPOINT, fetch=False):
-    nonce_key = tx.get("nonceKey", None)
-    nonce = tx.get("nonce", None)
-
-    if nonce_key is None:
-        if nonce_mode == NonceMode.RANDOM_KEY:
-            nonce_key = get_random_nonce_key()
-        else:
-            nonce_key = AA_BUNDLER_NONCE_KEY
-
-    if nonce is None:
-        if fetch or nonce_mode == NonceMode.FIXED_KEY_FETCH_ALWAYS:
-            nonce = fetch_nonce(w3, get_sender(tx), entry_point, nonce_key)
-        else:
-            nonce = NONCE_CACHE[nonce_key]
-    return nonce_key, nonce
-
-
 def consume_nonce(nonce_key, nonce):
     NONCE_CACHE[nonce_key] = max(NONCE_CACHE[nonce_key], nonce + 1)
 
@@ -182,104 +284,128 @@ def check_nonce_error(resp, retry_nonce):
         raise RevertError(resp["error"]["message"])
 
 
-def get_base_fee(w3):
-    blk = w3.eth.get_block("latest")
-    return int(_to_uint(blk["baseFeePerGas"]) * AA_BUNDLER_BASE_GAS_PRICE_FACTOR)
-
-
 def get_sender(tx):
-    if "from" not in tx or tx["from"] == ADDRESS_ZERO:
+    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"]
-
-
-def build_user_operation(w3, tx, retry_nonce=None):
-    nonce_key, nonce = get_nonce_and_key(
-        w3, tx, AA_BUNDLER_NONCE_MODE, entry_point=AA_BUNDLER_ENTRYPOINT, fetch=retry_nonce is not None
-    )
-    # "0xb61d27f6" = bytes4 hash of execute(address,uint256,bytes)
-    call_data = (
-        "0xb61d27f6"
-        + encode(["address", "uint256", "bytes"], [tx["to"], tx["value"], HexBytes(tx["data"])]).hex()
-    )
-    dummy_signature = (
-        "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007"
-        "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c"
-    )
-    user_operation = {
-        "sender": get_sender(tx),
-        "nonce": hex(make_nonce(nonce_key, nonce)),
-        "callData": call_data,
-        "signature": dummy_signature,
-    }
-
-    if AA_BUNDLER_PROVIDER == "alchemy":
-        resp = w3.provider.make_request(
-            "eth_estimateUserOperationGas", [user_operation, AA_BUNDLER_ENTRYPOINT]
+        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:
-            next_nonce = check_nonce_error(resp, retry_nonce)
-            return build_user_operation(w3, tx, retry_nonce=next_nonce)
+            raise RevertError(resp["error"]["message"])
 
-        user_operation.update(resp["result"])
+        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
+            ),
+        )
 
-        resp = w3.provider.make_request("rundler_maxPriorityFeePerGas", [])
+    def alchemy_gas_price(self):
+        resp = self.bundler.provider.make_request("rundler_maxPriorityFeePerGas", [])
         if "error" in resp:
             raise RevertError(resp["error"]["message"])
-        user_operation["maxPriorityFeePerGas"] = resp["result"]
-        user_operation["maxFeePerGas"] = hex(int(resp["result"], 16) + get_base_fee(w3))
+        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()
 
-    elif AA_BUNDLER_PROVIDER == "generic":
-        resp = w3.provider.make_request(
-            "eth_estimateUserOperationGas", [user_operation, AA_BUNDLER_ENTRYPOINT]
-        )
-        if "error" in resp:
-            next_nonce = check_nonce_error(resp, retry_nonce)
-            return build_user_operation(w3, tx, retry_nonce=next_nonce)
+        return GasPrice(max_priority_fee_per_gas=max_priority_fee_per_gas, max_fee_per_gas=max_fee_per_gas)
 
-        user_operation.update(resp["result"])
+    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)
 
-    else:
-        warn(f"Unknown AA_BUNDLER_PROVIDER: {AA_BUNDLER_PROVIDER}")
-
-    # Apply increase factors
-    user_operation["verificationGasLimit"] = hex(
-        apply_factor(user_operation["verificationGasLimit"], AA_BUNDLER_VERIFICATION_GAS_FACTOR)
-    )
-    if "maxPriorityFeePerGas" in user_operation:
-        user_operation["maxPriorityFeePerGas"] = hex(
-            apply_factor(user_operation["maxPriorityFeePerGas"], AA_BUNDLER_PRIORITY_GAS_PRICE_FACTOR)
-        )
-    if "callGasLimit" in user_operation:
-        user_operation["callGasLimit"] = hex(
-            apply_factor(user_operation["callGasLimit"], AA_BUNDLER_GAS_LIMIT_FACTOR)
-        )
+        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)
 
-    # Remove paymaster related fields
-    user_operation.pop("paymaster", None)
-    user_operation.pop("paymasterData", None)
-    user_operation.pop("paymasterVerificationGasLimit", None)
-    user_operation.pop("paymasterPostOpGasLimit", None)
+        if self.bundler_type == "alchemy":
+            gas_price = self.alchemy_gas_price()
+            user_operation = user_operation.add_gas_price(gas_price)
 
-    # Consume the nonce, even if the userop may fail later
-    consume_nonce(nonce_key, nonce)
+        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
+        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
+        )
 
-def send_transaction(w3, tx, retry_nonce=None):
-    user_operation = build_user_operation(w3, tx, retry_nonce)
-    user_operation["signature"] = add_0x_prefix(
-        sign_user_operation(
-            AA_BUNDLER_EXECUTOR_PK, user_operation, tx["chainId"], AA_BUNDLER_ENTRYPOINT
-        ).hex()
-    )
-    resp = w3.provider.make_request("eth_sendUserOperation", [user_operation, AA_BUNDLER_ENTRYPOINT])
-    if "error" in resp:
-        next_nonce = check_nonce_error(resp, retry_nonce)
-        return send_transaction(w3, tx, retry_nonce=next_nonce)
+        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"]}
+        return {"userOpHash": resp["result"]}

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)

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

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"]

eth_prototype-1.2.1.dist-info/RECORD

@@ -1,14 +0,0 @@
-ethproto/__init__.py,sha256=YWkAFysBp4tZjLWWB2FFmp5yG23pUYhQvgQW9b3soXs,579
-ethproto/aa_bundler.py,sha256=XcSshufDoDAZU2mGaI5Kl8BSiidyIMLNhFKSmwOj5Bk,10544
-ethproto/build_artifacts.py,sha256=xwCd5hJUHP82IA-y3sSfX6fV15kjCGtV19RxNRcoor0,5441
-ethproto/contracts.py,sha256=rNVbCK1hURy7lWKhzSdXgVWo3wx9O_Ghk-6PfgOsRNk,18662
-ethproto/defender_relay.py,sha256=05A8TfRZwiBhCpo924Pf9CjfKSir2Wvgg1p_asFxJbw,1777
-ethproto/w3wrappers.py,sha256=4ZEnJFrc8bV1qHG4dNdom4FL1gEUhgoJORY6cGzlJDk,21549
-ethproto/wadray.py,sha256=JBsu5KcyU9k70bDK03T2IY6qPVFO30WbYPhwrAHdXao,8262
-ethproto/wrappers.py,sha256=9qDwRDOXw3wquzvGfIsub-VPWm98GBWP7dHLFOUPWzg,17307
-eth_prototype-1.2.1.dist-info/AUTHORS.rst,sha256=Ui-05yYXtDZxna6o1yNcfdm8Jt68UIDQ01osiLxlYlU,95
-eth_prototype-1.2.1.dist-info/LICENSE.txt,sha256=U_Q6_nDYDwZPIuhttHi37hXZ2qU2-HlV2geo9hzHXFw,1087
-eth_prototype-1.2.1.dist-info/METADATA,sha256=Qom0naY8c8M2mBdjBHHh9SGOsLPkhgsIOQtCA9dYVBM,2482
-eth_prototype-1.2.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-eth_prototype-1.2.1.dist-info/top_level.txt,sha256=Dl0X7m6N1hxeo4JpGpSNqWC2gtsN0731g-DL1J0mpjc,9
-eth_prototype-1.2.1.dist-info/RECORD,,