eth-prototype 1.0.1__tar.gz → 1.1.1__tar.gz

{eth_prototype-1.0.1 → eth_prototype-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: eth-prototype
-Version: 1.0.1
+Version: 1.1.1
 Summary: Prototype Ethereum Smart Contracts in Python
 Home-page: https://github.com/gnarvaja/eth-prototype
 Author: Guillermo M. Narvaja
@@ -20,7 +20,7 @@ Requires-Dist: requests
 Requires-Dist: hexbytes
 Requires-Dist: importlib-metadata; python_version < "3.8"
 Provides-Extra: web3
-Requires-Dist: web3>=6; extra == "web3"
+Requires-Dist: web3==6.*; extra == "web3"
 Provides-Extra: defender
 Requires-Dist: boto3; extra == "defender"
 Provides-Extra: gmpy2
@@ -30,12 +30,8 @@ Requires-Dist: setuptools; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: gmpy2; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
-Provides-Extra: testing-w3
-Requires-Dist: web3[tester]>=6; extra == "testing-w3"
-Requires-Dist: setuptools; extra == "testing-w3"
-Requires-Dist: pytest; extra == "testing-w3"
-Requires-Dist: pytest-cov; extra == "testing-w3"
-Requires-Dist: boto3; extra == "testing-w3"
+Requires-Dist: web3[tester]==6.*; extra == "testing"
+Requires-Dist: boto3; extra == "testing"
 
 # eth-prototype
 

{eth_prototype-1.0.1 → eth_prototype-1.1.1}/setup.cfg

@@ -35,7 +35,7 @@ exclude =
 
 [options.extras_require]
 web3 = 
-	web3>=6
+	web3==6.*
 defender = 
 	boto3
 gmpy2 = 
@@ -45,11 +45,7 @@ testing =
 	pytest
 	gmpy2
 	pytest-cov
-testing-w3 = 
-	web3[tester]>=6
-	setuptools
-	pytest
-	pytest-cov
+	web3[tester]==6.*
 	boto3
 
 [options.entry_points]

{eth_prototype-1.0.1 → eth_prototype-1.1.1}/src/eth_prototype.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: eth-prototype
-Version: 1.0.1
+Version: 1.1.1
 Summary: Prototype Ethereum Smart Contracts in Python
 Home-page: https://github.com/gnarvaja/eth-prototype
 Author: Guillermo M. Narvaja
@@ -20,7 +20,7 @@ Requires-Dist: requests
 Requires-Dist: hexbytes
 Requires-Dist: importlib-metadata; python_version < "3.8"
 Provides-Extra: web3
-Requires-Dist: web3>=6; extra == "web3"
+Requires-Dist: web3==6.*; extra == "web3"
 Provides-Extra: defender
 Requires-Dist: boto3; extra == "defender"
 Provides-Extra: gmpy2
@@ -30,12 +30,8 @@ Requires-Dist: setuptools; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: gmpy2; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
-Provides-Extra: testing-w3
-Requires-Dist: web3[tester]>=6; extra == "testing-w3"
-Requires-Dist: setuptools; extra == "testing-w3"
-Requires-Dist: pytest; extra == "testing-w3"
-Requires-Dist: pytest-cov; extra == "testing-w3"
-Requires-Dist: boto3; extra == "testing-w3"
+Requires-Dist: web3[tester]==6.*; extra == "testing"
+Requires-Dist: boto3; extra == "testing"
 
 # eth-prototype
 

{eth_prototype-1.0.1 → eth_prototype-1.1.1}/src/eth_prototype.egg-info/SOURCES.txt

@@ -29,6 +29,7 @@ src/eth_prototype.egg-info/not-zip-safe
 src/eth_prototype.egg-info/requires.txt
 src/eth_prototype.egg-info/top_level.txt
 src/ethproto/__init__.py
+src/ethproto/aa_bundler.py
 src/ethproto/build_artifacts.py
 src/ethproto/contracts.py
 src/ethproto/defender_relay.py
@@ -36,6 +37,7 @@ src/ethproto/w3wrappers.py
 src/ethproto/wadray.py
 src/ethproto/wrappers.py
 tests/conftest.py
+tests/test_aa_bundler.py
 tests/test_build_artifacts.py
 tests/test_contracts.py
 tests/test_defender.py

{eth_prototype-1.0.1 → eth_prototype-1.1.1}/src/eth_prototype.egg-info/requires.txt

@@ -17,13 +17,8 @@ setuptools
 pytest
 gmpy2
 pytest-cov
-
-[testing-w3]
-web3[tester]>=6
-setuptools
-pytest
-pytest-cov
+web3[tester]==6.*
 boto3
 
 [web3]
-web3>=6
+web3==6.*

eth_prototype-1.1.1/src/ethproto/aa_bundler.py

@@ -0,0 +1,250 @@
+import random
+from warnings import warn
+from enum import Enum
+import requests
+from environs import Env
+from eth_abi import encode
+from eth_account import Account
+from eth_account.messages import encode_defunct
+from hexbytes import HexBytes
+from web3 import Web3
+from web3.constants import ADDRESS_ZERO
+from .contracts import RevertError
+
+
+env = Env()
+
+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)
+
+NonceMode = Enum(
+    "NonceMode",
+    [
+        "RANDOM_KEY",  # first time initializes a random key and increments nonce locally with calling the blockchain
+        "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 = {}
+RANDOM_NONCE_KEY = None
+
+
+def pack_two(a, b):
+    a = HexBytes(a).hex()[2:]
+    b = HexBytes(b).hex()[2:]
+    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 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()
+    ).hex()
+
+
+def hash_packed_user_operation(packed_user_op, chain_id, entry_point):
+    return Web3.keccak(
+        hexstr=encode(
+            ["bytes32", "address", "uint256"],
+            [HexBytes(hash_packed_user_operation_only(packed_user_op)), entry_point, chain_id],
+        ).hex()
+    ).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), private_key)
+    return signature.signature.hex()
+
+
+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)
+    return ep.functions.getNonce(account, nonce_key).call()
+
+
+def get_random_nonce_key():
+    global RANDOM_NONCE_KEY
+    if RANDOM_NONCE_KEY is None:
+        RANDOM_NONCE_KEY = random.randint(1, 2**192 - 1)
+    return RANDOM_NONCE_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)
+        elif nonce_key not in NONCE_CACHE:
+            nonce = 0
+        else:
+            nonce = NONCE_CACHE[nonce_key]
+    return nonce_key, nonce
+
+
+def handle_response_error(resp, w3, tx, retry_nonce):
+    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 send_transaction(w3, tx, retry_nonce=(retry_nonce or 0) + 1)
+    else:
+        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 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 send_transaction(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]
+        )
+        if "error" in resp:
+            return handle_response_error(resp, w3, tx, retry_nonce)
+
+        user_operation.update(resp["result"])
+
+        resp = w3.provider.make_request("rundler_maxPriorityFeePerGas", [])
+        if "error" in resp:
+            raise RevertError(resp["error"]["message"])
+        max_priority_fee_per_gas = int(_to_uint(resp["result"]) * AA_BUNDLER_PRIORITY_GAS_PRICE_FACTOR)
+        user_operation["maxPriorityFeePerGas"] = hex(max_priority_fee_per_gas)
+        user_operation["maxFeePerGas"] = hex(max_priority_fee_per_gas + get_base_fee(w3))
+        user_operation["callGasLimit"] = hex(
+            int(_to_uint(user_operation["callGasLimit"]) * AA_BUNDLER_GAS_LIMIT_FACTOR)
+        )
+    elif AA_BUNDLER_PROVIDER == "gelato":
+        user_operation.update(
+            {
+                "preVerificationGas": "0x00",
+                "callGasLimit": "0x00",
+                "verificationGasLimit": "0x00",
+                "maxFeePerGas": "0x00",
+                "maxPriorityFeePerGas": "0x00",
+            }
+        )
+    user_operation["signature"] = sign_user_operation(
+        AA_BUNDLER_EXECUTOR_PK, user_operation, tx["chainId"], AA_BUNDLER_ENTRYPOINT
+    )
+    # Remove paymaster related fields
+    user_operation.pop("paymaster", None)
+    user_operation.pop("paymasterData", None)
+    user_operation.pop("paymasterVerificationGasLimit", None)
+    user_operation.pop("paymasterPostOpGasLimit", None)
+
+    resp = w3.provider.make_request("eth_sendUserOperation", [user_operation, AA_BUNDLER_ENTRYPOINT])
+    if "error" in resp:
+        return handle_response_error(resp, w3, tx, retry_nonce)
+
+    # Store nonce in the cache, so next time uses a new nonce
+    NONCE_CACHE[nonce_key] = nonce + 1
+    return {"userOpHash": resp["result"]}

{eth_prototype-1.0.1 → eth_prototype-1.1.1}/src/ethproto/build_artifacts.py

@@ -1,6 +1,5 @@
 """Helper classes to use hardhat build artifacts from python"""
 
-
 import json
 import os
 import os.path
@@ -26,17 +25,15 @@ class Artifact:
         self.abi = kwargs["abi"]
         self.bytecode = kwargs["bytecode"]
         self.deployed_bytecode = kwargs["deployedBytecode"]
-        self.link_references = kwargs["linkReferences"]
-        self.deployed_link_references = kwargs["deployedLinkReferences"]
+        self.link_references = kwargs.get("linkReferences", {})
+        self.deployed_link_references = kwargs.get("deployedLinkReferences", {})
 
     def link(self, libraries: dict) -> "Artifact":
         """Returns a new artifact with the external libraries linked
 
         Libraries is a dictionary of the form {library_name: address}
         """
-        bytecode = self._replace_link_references(
-            self.bytecode, self.link_references, libraries
-        )
+        bytecode = self._replace_link_references(self.bytecode, self.link_references, libraries)
         deployed_bytecode = self._replace_link_references(
             self.deployed_bytecode, self.deployed_link_references, libraries
         )
@@ -55,9 +52,7 @@ class Artifact:
             for lib in libs.keys():
                 yield lib, source
 
-    def _replace_link_references(
-        self, bytecode: str, link_references: dict, libraries: dict
-    ) -> str:
+    def _replace_link_references(self, bytecode: str, link_references: dict, libraries: dict) -> str:
         # remove 0x prefix if present
         bytecode = bytecode[2:] if bytecode.startswith("0x") else bytecode
 
@@ -115,17 +110,13 @@ class ArtifactLibrary:
 
         if contract not in self._fullpath_cache:
             for path in self.lookup_paths:
-                build_artifact_path = (
-                    path / contract / contract.with_suffix(".json").name
-                )
+                build_artifact_path = path / contract / contract.with_suffix(".json").name
                 if build_artifact_path.exists():
                     with open(build_artifact_path) as f:
                         self._fullpath_cache[contract] = Artifact(**json.load(f))
 
             if contract not in self._fullpath_cache:
-                raise FileNotFoundError(
-                    f"Could not find artifact for {contract} on {self.lookup_paths}"
-                )
+                raise FileNotFoundError(f"Could not find artifact for {contract} on {self.lookup_paths}")
 
         return self._fullpath_cache[contract]
 
@@ -145,8 +136,6 @@ class ArtifactLibrary:
                             self._name_cache[contract_name] = Artifact(**json.load(f))
 
             if contract_name not in self._name_cache:
-                raise FileNotFoundError(
-                    f"Could not find artifact for {contract_name} on {self.lookup_paths}"
-                )
+                raise FileNotFoundError(f"Could not find artifact for {contract_name} on {self.lookup_paths}")
 
         return self._name_cache[contract_name]

{eth_prototype-1.0.1 → eth_prototype-1.1.1}/src/ethproto/w3wrappers.py

@@ -108,9 +108,19 @@ def transact(provider, function, tx_kwargs):
     elif W3_TRANSACT_MODE == "defender-async":
         from .defender_relay import send_transaction
 
-        tx_kwargs = {**provider.tx_kwargs, **tx_kwargs}
+        tx_kwargs |= provider.tx_kwargs
         tx = function.build_transaction(tx_kwargs)
         return send_transaction(tx)
+    elif W3_TRANSACT_MODE == "aa-bundler-async":
+        from .aa_bundler import send_transaction
+
+        tx_kwargs |= provider.tx_kwargs
+        # To avoid fetching gas and gasPrice in a standard way, when it's not relevant for user ops
+        tx_kwargs.update(dict(gas=0, gasPrice=0))
+        tx = function.build_transaction(tx_kwargs)
+        return send_transaction(provider.w3, tx)
+    else:
+        raise RuntimeError(f"Unknown W3_TRANSACT_MODE {W3_TRANSACT_MODE}")
 
     return provider.w3.eth.wait_for_transaction_receipt(tx_hash)
 
@@ -365,6 +375,8 @@ class W3ETHCall(ETHCall):
     def normalize_receipt(self, wrapper, receipt):
         if W3_TRANSACT_MODE == "defender-async":
             return receipt  # Don't do anything because the receipt is just a dict of not-yet-mined tx
+        elif W3_TRANSACT_MODE == "aa-bundler-async":
+            return receipt  # Don't do anything because the receipt is just a dict of {"userOpHash": "..."}
         return ReceiptWrapper(receipt, wrapper.contract)
 
     def _handle_exception(self, err):

eth_prototype-1.1.1/tests/test_aa_bundler.py

@@ -0,0 +1,244 @@
+import os
+from hexbytes import HexBytes
+from ethproto import aa_bundler
+from web3.constants import HASH_ZERO
+from unittest.mock import MagicMock, patch
+
+
+def test_pack_two():
+    assert aa_bundler.pack_two(0, 0) == HASH_ZERO
+    assert aa_bundler.pack_two(1, 2) == "0x0000000000000000000000000000000100000000000000000000000000000002"
+    assert (
+        aa_bundler.pack_two("0x1", "0x2")
+        == "0x0000000000000000000000000000000100000000000000000000000000000002"
+    )
+    assert aa_bundler.pack_two(HexBytes(2), HexBytes(3) == "0x{:032x}{:032x}".format(2, 3))
+
+
+TEST_CALL_DATA = "0x47e1da2a000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000020000000000000000000000002791bca1f2de4661ed88a30c99a7a9449aa841740000000000000000000000002791bca1f2de4661ed88a30c99a7a9449aa8417400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000044a9059cbb00000000000000000000000070997970c51812dc3a010c7d01b50e0d17dc79c800000000000000000000000000000000000000000000000000000000004c4b40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044a9059cbb0000000000000000000000003c44cdddb6a900fa2b585dd299e03d12fa4293bc000000000000000000000000000000000000000000000000000000000098968000000000000000000000000000000000000000000000000000000000"  # noqa
+
+# Private key of index=1 of seed phrase ["test"] * 11 + ["junk"]
+TEST_PRIVATE_KEY = "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d"
+CHAIN_ID = 31337
+ENTRYPOINT = "0x0000000071727De22E5E9d8BAf0edAc6f37da032"
+
+TEST_SENDER = "0x8961423b54f06bf6D57F8dD3dD1184FA6F3aac3f"
+
+user_operation = {
+    "sender": TEST_SENDER,
+    "nonce": 0,
+    "initCode": "0x",
+    "callData": TEST_CALL_DATA,
+    "callGasLimit": 999999,
+    "verificationGasLimit": 999999,
+    "preVerificationGas": 999999,
+    "maxFeePerGas": 1000000000,
+    "maxPriorityFeePerGas": 1000000000,
+    "paymaster": "0x0000000000000000000000000000000000000000",
+    "paymasterData": "0x",
+    "paymasterVerificationGasLimit": 0,
+    "paymasterPostOpGasLimit": 0,
+}
+
+
+def test_pack_user_operation():
+    expected = {
+        "sender": TEST_SENDER,
+        "nonce": 0,
+        "initCode": "0x",
+        "callData": TEST_CALL_DATA,
+        "accountGasLimits": "0x000000000000000000000000000f423f000000000000000000000000000f423f",
+        "preVerificationGas": 999999,
+        "gasFees": "0x0000000000000000000000003b9aca000000000000000000000000003b9aca00",
+        "paymasterAndData": "0x",
+        "signature": "0x",
+    }
+    assert aa_bundler.pack_user_operation(user_operation) == expected
+
+
+def test_hash_packed_user_operation():
+    packed = aa_bundler.pack_user_operation(user_operation)
+    hash = aa_bundler.hash_packed_user_operation_only(packed)
+    assert hash == "0xa2c19765d18b0d690c05b20061bd23d066201aff1833a51bd28af115fbd4bcd9"
+    hash = aa_bundler.hash_packed_user_operation(packed, CHAIN_ID, ENTRYPOINT)
+    assert hash == "0xb365ad4d366e9081718e926912da7a78a2faae592286fda0cc11923bd141b7cf"
+
+
+def test_sign_user_operation():
+    signature = aa_bundler.sign_user_operation(TEST_PRIVATE_KEY, user_operation, CHAIN_ID, ENTRYPOINT)
+    assert (
+        signature
+        == "0xb9b872bfe4e90f4628e8ec24879a5b01045f91da8457f3ce2b417d2e5774b508261ec1147a820e75a141cb61b884a78d7e88996ceddafb9a7016cfe7a48a1f4f1b"  # noqa
+    )
+
+
+def test_sign_user_operation_gas_diff():
+    user_operation_2 = dict(user_operation)
+    user_operation_2["maxPriorityFeePerGas"] -= 1
+    signature = aa_bundler.sign_user_operation(TEST_PRIVATE_KEY, user_operation_2, CHAIN_ID, ENTRYPOINT)
+    assert (
+        signature
+        == "0x8162479d2dbd18d7fe93a2f51e283021d6e4eae4f57d20cdd553042723a0b0ea690ab3903d45126b0047da08ab53dfdf86656e4f258ac4936ba96a759ccb77f61b"  # noqa
+    )
+
+
+def test_make_nonce():
+    assert aa_bundler.make_nonce(0, 0) == 0
+    assert aa_bundler.make_nonce(0, 1) == 1
+    assert aa_bundler.make_nonce(1, 1) == (1 << 64) + 1
+
+
+FAIL_IF_USED = object()
+
+
+@patch.object(aa_bundler.random, "randint")
+@patch.object(aa_bundler, "fetch_nonce")
+def test_get_nonce_force_fetch(fetch_nonce_mock, randint_mock):
+    # Test fetch=True
+    fetch_nonce_mock.return_value = 123
+    assert aa_bundler.get_nonce_and_key(
+        FAIL_IF_USED,
+        {"nonceKey": 12, "from": TEST_SENDER},
+        nonce_mode=aa_bundler.NonceMode.FIXED_KEY_LOCAL_NONCE,
+        fetch=True,
+    ) == (12, 123)
+    fetch_nonce_mock.assert_called_once_with(FAIL_IF_USED, TEST_SENDER, ENTRYPOINT, 12)
+    randint_mock.assert_not_called()
+
+
+@patch.object(aa_bundler.random, "randint")
+@patch.object(aa_bundler, "fetch_nonce")
+def test_get_nonce_fetch_always_mode(fetch_nonce_mock, randint_mock):
+    # Test nonce_mode=NonceMode.FIXED_KEY_FETCH_ALWAYS
+    fetch_nonce_mock.return_value = 111
+    assert aa_bundler.get_nonce_and_key(
+        FAIL_IF_USED,
+        {"nonceKey": 22, "from": TEST_SENDER},
+        nonce_mode=aa_bundler.NonceMode.FIXED_KEY_FETCH_ALWAYS,
+    ) == (22, 111)
+    fetch_nonce_mock.assert_called_once_with(FAIL_IF_USED, TEST_SENDER, ENTRYPOINT, 22)
+    randint_mock.assert_not_called()
+    fetch_nonce_mock.reset_mock()
+
+
+@patch.object(aa_bundler.random, "randint")
+@patch.object(aa_bundler, "fetch_nonce")
+def test_get_nonce_nonce_key_in_tx(fetch_nonce_mock, randint_mock):
+    # Test nonce_mode=NonceMode.FIXED_KEY_LOCAL_NONCE
+    assert aa_bundler.get_nonce_and_key(
+        FAIL_IF_USED,
+        {"nonceKey": 22, "from": TEST_SENDER},
+        nonce_mode=aa_bundler.NonceMode.FIXED_KEY_LOCAL_NONCE,
+    ) == (22, 0)
+    randint_mock.assert_not_called()
+    fetch_nonce_mock.assert_not_called()
+
+    # Same if nonce_mode=NonceMode.RANDOM_KEY but nonceKey in the tx
+    assert aa_bundler.get_nonce_and_key(
+        FAIL_IF_USED,
+        {"nonceKey": 22, "from": TEST_SENDER},
+        nonce_mode=aa_bundler.NonceMode.RANDOM_KEY,
+    ) == (22, 0)
+    randint_mock.assert_not_called()
+    fetch_nonce_mock.assert_not_called()
+
+
+@patch.object(aa_bundler.random, "randint")
+@patch.object(aa_bundler, "fetch_nonce")
+def test_get_nonce_random_key_mode(fetch_nonce_mock, randint_mock):
+    # If nonce_mode=NonceMode.RANDOM_KEY creates a random key and stores it
+    randint_mock.return_value = 444
+    assert aa_bundler.get_nonce_and_key(
+        FAIL_IF_USED,
+        {"from": TEST_SENDER},
+        nonce_mode=aa_bundler.NonceMode.RANDOM_KEY,
+    ) == (444, 0)
+    fetch_nonce_mock.assert_not_called()
+    randint_mock.assert_called_with(1, 2**192 - 1)
+    randint_mock.reset_mock()
+    assert aa_bundler.RANDOM_NONCE_KEY == 444
+    aa_bundler.RANDOM_NONCE_KEY = None  # cleanup
+
+
+@patch.object(aa_bundler.random, "randint")
+@patch.object(aa_bundler, "fetch_nonce")
+def test_get_nonce_with_local_cache(fetch_nonce_mock, randint_mock):
+    with patch.object(aa_bundler, "AA_BUNDLER_NONCE_KEY", new=55), patch.object(
+        aa_bundler, "NONCE_CACHE", new={55: 33}
+    ):
+        # Test nonce_mode=NonceMode.FIXED_KEY_LOCAL_NONCE
+        assert aa_bundler.get_nonce_and_key(
+            FAIL_IF_USED,
+            {"from": TEST_SENDER},
+            nonce_mode=aa_bundler.NonceMode.FIXED_KEY_LOCAL_NONCE,
+        ) == (55, 33)
+        randint_mock.assert_not_called()
+        fetch_nonce_mock.assert_not_called()
+
+
+@patch.object(aa_bundler, "AA_BUNDLER_NONCE_MODE", new=aa_bundler.NonceMode.FIXED_KEY_LOCAL_NONCE)
+@patch.object(aa_bundler, "get_base_fee")
+def test_send_transaction(get_base_fee_mock):
+    get_base_fee_mock.return_value = 0
+    w3 = MagicMock()
+    w3.eth.chain_id = CHAIN_ID
+
+    aa_bundler.AA_BUNDLER_EXECUTOR_PK = TEST_PRIVATE_KEY
+
+    tx = {
+        "value": 0,
+        "chainId": 137,
+        "from": "0xE8B412158c205B0F605e0FC09dCdA27d3F140FE9",
+        "to": "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
+        "data": "0x095ea7b30000000000000000000000007ace242f32208d836a2245df957c08547059bf45ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",  # noqa
+    }
+
+    def make_request(method, params):
+        if method == "eth_estimateUserOperationGas":
+            assert len(params) == 2
+            assert params[1] == ENTRYPOINT
+            assert params[0] == {
+                "sender": "0xE8B412158c205B0F605e0FC09dCdA27d3F140FE9",
+                "nonce": "0x0",
+                "callData": "0xb61d27f60000000000000000000000002791bca1f2de4661ed88a30c99a7a9449aa84174000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044095ea7b30000000000000000000000007ace242f32208d836a2245df957c08547059bf45ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000",  # noqa
+                "signature": "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c",  # noqa
+            }
+            return {
+                "jsonrpc": "2.0",
+                "id": 1,
+                "result": {
+                    "preVerificationGas": "0xb430",
+                    "callGasLimit": "0xcbb8",
+                    "verificationGasLimit": "0x13664",
+                    "paymasterVerificationGasLimit": None,
+                },
+            }
+        elif method == "rundler_maxPriorityFeePerGas":
+            assert len(params) == 0
+            return {"jsonrpc": "2.0", "id": 1, "result": "0x7ffffffff"}
+        elif method == "eth_sendUserOperation":
+            assert len(params) == 2
+            assert params[1] == ENTRYPOINT
+            assert params[0] == {
+                "sender": "0xE8B412158c205B0F605e0FC09dCdA27d3F140FE9",
+                "nonce": "0x0",
+                "callData": "0xb61d27f60000000000000000000000002791bca1f2de4661ed88a30c99a7a9449aa84174000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044095ea7b30000000000000000000000007ace242f32208d836a2245df957c08547059bf45ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000",  # noqa
+                "callGasLimit": "0xcbb8",
+                "verificationGasLimit": "0x13664",
+                "preVerificationGas": "0xb430",
+                "maxFeePerGas": "0x7ffffffff",
+                "maxPriorityFeePerGas": "0x7ffffffff",
+                "signature": "0x7980544d044bc1202fed7edec96f2fa795ab8670b439935e6bbb5104e95d84ea32af8bff187913ff7eb2b442baab06d0c300273942e312332659ab0a194bbbe81c",  # noqa
+            }
+            return {
+                "jsonrpc": "2.0",
+                "id": 1,
+                "result": "0xa950a17ca1ed83e974fb1aa227360a007cb65f566518af117ffdbb04d8d2d524",
+            }
+
+    w3.provider.make_request.side_effect = make_request
+
+    ret = aa_bundler.send_transaction(w3, tx)
+    get_base_fee_mock.assert_called_once_with(w3)
+    assert aa_bundler.NONCE_CACHE[0] == 1
+    assert ret == {"userOpHash": "0xa950a17ca1ed83e974fb1aa227360a007cb65f566518af117ffdbb04d8d2d524"}

{eth_prototype-1.0.1 → eth_prototype-1.1.1}/tox.ini

@@ -4,12 +4,12 @@
 
 [tox]
 minversion = 3.15
-envlist = {py39,py310}, {py39,py310}-w3
+envlist = {py39,py310}
 
 [gh-actions]
 python =
-    3.9: py39, py39-w3
-    3.10: py310, py310-w3
+    3.9: py39
+    3.10: py310
 
 [testenv]
 description = invoke pytest to run automated tests
@@ -20,26 +20,12 @@ setenv =
 passenv =
     HOME
     WADRAY_USE_GMPY2
-extras =
-    testing
-commands =
-    pytest {posargs}
-
-
-[testenv:{py39,py310}-w3]
-description = invoke pytest to run automated tests
-isolated_build = True
-setenv =
-    TOXINIDIR = {toxinidir}
-    TEST_ENV = web3py
-passenv =
-    HOME
     W3_*
     TRANSACT_MODE
     WEB3_PROVIDER_URI
     WEB3_*
 extras =
-    testing-w3
+    testing
 deps =
     warrant @ git+https://github.com/gnarvaja/warrant.git#egg=warrant
 commands =