web3 7.0.0b1__py3-none-any.whl → 7.7.0__py3-none-any.whl

web3/_utils/module_testing/go_ethereum_personal_module.py

@@ -1,300 +0,0 @@
-import json
-import pytest
-from typing import (
-    TYPE_CHECKING,
-    cast,
-)
-
-from eth_typing import (
-    ChecksumAddress,
-)
-from eth_utils import (
-    is_checksum_address,
-    is_list_like,
-    is_same_address,
-    is_string,
-)
-from hexbytes import (
-    HexBytes,
-)
-
-from web3 import (
-    constants,
-)
-from web3.datastructures import (
-    AttributeDict,
-)
-from web3.types import (
-    TxParams,
-    Wei,
-)
-
-if TYPE_CHECKING:
-    from web3 import (  # noqa: F401
-        AsyncWeb3,
-        Web3,
-    )
-
-PRIVATE_KEY_HEX = "0x56ebb41875ceedd42e395f730e03b5c44989393c9f0484ee6bc05f933673458f"
-SECOND_PRIVATE_KEY_HEX = (
-    "0x56ebb41875ceedd42e395f730e03b5c44989393c9f0484ee6bc05f9336712345"
-)
-THIRD_PRIVATE_KEY_HEX = (
-    "0x56ebb41875ceedd42e395f730e03b5c44989393c9f0484ee6bc05f9336754321"
-)
-PASSWORD = "web3-testing"
-ADDRESS = "0x844B417c0C58B02c2224306047B9fb0D3264fE8c"
-SECOND_ADDRESS = "0xB96b6B21053e67BA59907E252D990C71742c41B8"
-
-
-PRIVATE_KEY_FOR_UNLOCK = (
-    "0x392f63a79b1ff8774845f3fa69de4a13800a59e7083f5187f1558f0797ad0f01"
-)
-ACCOUNT_FOR_UNLOCK = "0x12efDc31B1a8FA1A1e756DFD8A1601055C971E13"
-
-
-class GoEthereumPersonalModuleTest:
-    def test_personal_import_raw_key(self, w3: "Web3") -> None:
-        actual = w3.geth.personal.import_raw_key(PRIVATE_KEY_HEX, PASSWORD)
-        assert actual == ADDRESS
-
-    def test_personal_list_accounts(self, w3: "Web3") -> None:
-        accounts = w3.geth.personal.list_accounts()
-        assert is_list_like(accounts)
-        assert len(accounts) > 0
-        assert all((is_checksum_address(item) for item in accounts))
-
-    def test_personal_list_wallets(self, w3: "Web3") -> None:
-        wallets = w3.geth.personal.list_wallets()
-        assert is_list_like(wallets)
-        assert len(wallets) > 0
-        assert is_checksum_address(wallets[0]["accounts"][0]["address"])
-        assert is_string(wallets[0]["accounts"][0]["url"])
-        assert is_string(wallets[0]["status"])
-        assert is_string(wallets[0]["url"])
-
-    def test_personal_lock_account(
-        self, w3: "Web3", unlockable_account_dual_type: ChecksumAddress
-    ) -> None:
-        # TODO: how do we test this better?
-        w3.geth.personal.lock_account(unlockable_account_dual_type)
-
-    def test_personal_unlock_account_success(
-        self,
-        w3: "Web3",
-        unlockable_account_dual_type: ChecksumAddress,
-        unlockable_account_pw: str,
-    ) -> None:
-        result = w3.geth.personal.unlock_account(
-            unlockable_account_dual_type, unlockable_account_pw
-        )
-        assert result is True
-
-    def test_personal_unlock_account_failure(
-        self, w3: "Web3", unlockable_account_dual_type: ChecksumAddress
-    ) -> None:
-        with pytest.raises(ValueError):
-            w3.geth.personal.unlock_account(
-                unlockable_account_dual_type, "bad-password"
-            )
-
-    def test_personal_new_account(self, w3: "Web3") -> None:
-        new_account = w3.geth.personal.new_account(PASSWORD)
-        assert is_checksum_address(new_account)
-
-    def test_personal_send_transaction(
-        self,
-        w3: "Web3",
-        unlockable_account_dual_type: ChecksumAddress,
-        unlockable_account_pw: str,
-    ) -> None:
-        assert (
-            w3.eth.get_balance(unlockable_account_dual_type) > constants.WEI_PER_ETHER
-        )
-        txn_params: TxParams = {
-            "from": unlockable_account_dual_type,
-            "to": unlockable_account_dual_type,
-            "gas": 21000,
-            "value": Wei(1),
-            "gasPrice": w3.to_wei(1, "gwei"),
-        }
-        txn_hash = w3.geth.personal.send_transaction(txn_params, unlockable_account_pw)
-        assert txn_hash
-        transaction = w3.eth.get_transaction(txn_hash)
-
-        assert is_same_address(
-            transaction["from"], cast(ChecksumAddress, txn_params["from"])
-        )
-        assert is_same_address(
-            transaction["to"], cast(ChecksumAddress, txn_params["to"])
-        )
-        assert transaction["gas"] == txn_params["gas"]
-        assert transaction["value"] == txn_params["value"]
-        assert transaction["gasPrice"] == txn_params["gasPrice"]
-
-    def test_personal_sign_and_ecrecover(
-        self,
-        w3: "Web3",
-        unlockable_account_dual_type: ChecksumAddress,
-        unlockable_account_pw: str,
-    ) -> None:
-        message = "test-web3-geth-personal-sign"
-        signature = w3.geth.personal.sign(
-            message, unlockable_account_dual_type, unlockable_account_pw
-        )
-        signer = w3.geth.personal.ec_recover(message, signature)
-        assert is_same_address(signer, unlockable_account_dual_type)
-
-    @pytest.mark.xfail(
-        reason="personal_sign_typed_data JSON RPC call has not been released in geth"
-    )
-    def test_personal_sign_typed_data(
-        self,
-        w3: "Web3",
-        unlockable_account_dual_type: ChecksumAddress,
-        unlockable_account_pw: str,
-    ) -> None:
-        typed_message = """
-            {
-                "types": {
-                    "EIP712Domain": [
-                        {"name": "name", "type": "string"},
-                        {"name": "version", "type": "string"},
-                        {"name": "chainId", "type": "uint256"},
-                        {"name": "verifyingContract", "type": "address"}
-                    ],
-                    "Person": [
-                        {"name": "name", "type": "string"},
-                        {"name": "wallet", "type": "address"}
-                    ],
-                    "Mail": [
-                        {"name": "from", "type": "Person"},
-                        {"name": "to", "type": "Person"},
-                        {"name": "contents", "type": "string"}
-                    ]
-                },
-                "primaryType": "Mail",
-                "domain": {
-                    "name": "Ether Mail",
-                    "version": "1",
-                    "chainId": "0x01",
-                    "verifyingContract": "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"
-                },
-                "message": {
-                    "from": {
-                        "name": "Cow",
-                        "wallet": "0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826"
-                    },
-                    "to": {
-                        "name": "Bob",
-                        "wallet": "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB"
-                    },
-                    "contents": "Hello, Bob!"
-                }
-            }
-        """
-        signature = HexBytes(
-            w3.geth.personal.sign_typed_data(
-                json.loads(typed_message),
-                unlockable_account_dual_type,
-                unlockable_account_pw,
-            )
-        )
-
-        expected_signature = HexBytes(
-            "0xc8b56aaeefd10ab4005c2455daf28d9082af661ac347cd"
-            "b612d5b5e11f339f2055be831bf57a6e6cb5f6d93448fa35"
-            "c1bd56fe1d745ffa101e74697108668c401c"
-        )
-        assert signature == expected_signature
-        assert len(signature) == 32 + 32 + 1
-
-
-class GoEthereumAsyncPersonalModuleTest:
-    @pytest.mark.asyncio
-    async def test_async_sign_and_ec_recover(
-        self,
-        async_w3: "AsyncWeb3",
-        async_unlockable_account_dual_type: ChecksumAddress,
-        unlockable_account_pw: str,
-    ) -> None:
-        message = "This is a test"
-        signature = await async_w3.geth.personal.sign(
-            message, async_unlockable_account_dual_type, unlockable_account_pw
-        )
-        address = await async_w3.geth.personal.ec_recover(message, signature)
-        assert is_same_address(async_unlockable_account_dual_type, address)
-
-    @pytest.mark.asyncio
-    async def test_async_import_key(self, async_w3: "AsyncWeb3") -> None:
-        address = await async_w3.geth.personal.import_raw_key(
-            THIRD_PRIVATE_KEY_HEX, "Testing"
-        )
-        assert address is not None
-
-    @pytest.mark.asyncio
-    async def test_async_list_accounts(self, async_w3: "AsyncWeb3") -> None:
-        accounts = await async_w3.geth.personal.list_accounts()
-        assert len(accounts) > 0
-
-    @pytest.mark.asyncio
-    async def test_async_list_wallets(self, async_w3: "AsyncWeb3") -> None:
-        wallets = await async_w3.geth.personal.list_wallets()
-        assert isinstance(wallets[0], AttributeDict)
-
-    @pytest.mark.asyncio
-    async def test_async_new_account(self, async_w3: "AsyncWeb3") -> None:
-        passphrase = "Create New Account"
-        account = await async_w3.geth.personal.new_account(passphrase)
-        assert is_checksum_address(account)
-
-    @pytest.mark.asyncio
-    async def test_async_unlock_lock_account(
-        self,
-        async_w3: "AsyncWeb3",
-        async_unlockable_account_dual_type: ChecksumAddress,
-        unlockable_account_pw: str,
-    ) -> None:
-        unlocked = await async_w3.geth.personal.unlock_account(
-            async_unlockable_account_dual_type, unlockable_account_pw
-        )
-        assert unlocked is True
-        locked = await async_w3.geth.personal.lock_account(
-            async_unlockable_account_dual_type
-        )
-        assert locked is True
-
-    @pytest.mark.asyncio
-    async def test_async_send_transaction(
-        self,
-        async_w3: "AsyncWeb3",
-        async_unlockable_account_dual_type: ChecksumAddress,
-        unlockable_account_pw: str,
-    ) -> None:
-        tx_params = TxParams()
-        tx_params["to"] = async_unlockable_account_dual_type
-        tx_params["from"] = async_unlockable_account_dual_type
-        tx_params["value"] = Wei(123)
-        response = await async_w3.geth.personal.send_transaction(
-            tx_params, unlockable_account_pw
-        )
-        assert response is not None
-
-    @pytest.mark.xfail(
-        reason="personal_signTypedData JSON RPC call has not been released in geth"
-    )
-    @pytest.mark.asyncio
-    async def test_async_sign_typed_data(
-        self,
-        async_w3: "AsyncWeb3",
-        async_unlockable_account_dual_type: ChecksumAddress,
-        unlockable_account_pw: str,
-    ) -> None:
-        message = {"message": "This is a test"}
-        signature = await async_w3.geth.personal.sign_typed_data(
-            message, async_unlockable_account_dual_type, unlockable_account_pw
-        )
-        address = await async_w3.geth.personal.ec_recover(
-            json.dumps(message), signature
-        )
-        assert is_same_address(async_unlockable_account_dual_type, address)

web3/_utils/request.py

@@ -1,265 +0,0 @@
-import asyncio
-from concurrent.futures import (
-    ThreadPoolExecutor,
-)
-import logging
-import os
-import threading
-from typing import (
-    Any,
-    Dict,
-    List,
-    Optional,
-    Union,
-)
-
-from aiohttp import (
-    ClientResponse,
-    ClientSession,
-    ClientTimeout,
-)
-from eth_typing import (
-    URI,
-)
-import requests
-
-from web3._utils.async_caching import (
-    async_lock,
-)
-from web3._utils.caching import (
-    generate_cache_key,
-)
-from web3.utils.caching import (
-    SimpleCache,
-)
-
-logger = logging.getLogger(__name__)
-
-DEFAULT_TIMEOUT = 10
-
-
-def get_default_http_endpoint() -> URI:
-    return URI(os.environ.get("WEB3_HTTP_PROVIDER_URI", "http://localhost:8545"))
-
-
-_session_cache = SimpleCache()
-_session_cache_lock = threading.Lock()
-
-
-def cache_and_return_session(
-    endpoint_uri: URI, session: requests.Session = None
-) -> requests.Session:
-    # cache key should have a unique thread identifier
-    cache_key = generate_cache_key(f"{threading.get_ident()}:{endpoint_uri}")
-
-    cached_session = _session_cache.get_cache_entry(cache_key)
-    if cached_session is not None:
-        # If read from cache yields a session, no need to lock; return the session.
-        # Sync is a bit simpler in this way since a `requests.Session` doesn't really
-        # "close" in the same way that an async `ClientSession` does. When "closed", it
-        # still uses http / https adapters successfully if a request is made.
-        return cached_session
-
-    if session is None:
-        session = requests.Session()
-
-    with _session_cache_lock:
-        cached_session, evicted_items = _session_cache.cache(cache_key, session)
-        logger.debug(f"Session cached: {endpoint_uri}, {cached_session}")
-
-    if evicted_items is not None:
-        evicted_sessions = evicted_items.values()
-        for evicted_session in evicted_sessions:
-            logger.debug(
-                f"Session cache full. Session evicted from cache: {evicted_session}",
-            )
-        threading.Timer(
-            DEFAULT_TIMEOUT + 0.1,
-            _close_evicted_sessions,
-            args=[evicted_sessions],
-        ).start()
-
-    return cached_session
-
-
-def get_response_from_get_request(
-    endpoint_uri: URI, *args: Any, **kwargs: Any
-) -> requests.Response:
-    kwargs.setdefault("timeout", DEFAULT_TIMEOUT)
-    session = cache_and_return_session(endpoint_uri)
-    response = session.get(endpoint_uri, *args, **kwargs)
-    return response
-
-
-def json_make_get_request(
-    endpoint_uri: URI, *args: Any, **kwargs: Any
-) -> Dict[str, Any]:
-    response = get_response_from_get_request(endpoint_uri, *args, **kwargs)
-    response.raise_for_status()
-    return response.json()
-
-
-def get_response_from_post_request(
-    endpoint_uri: URI, *args: Any, **kwargs: Any
-) -> requests.Response:
-    kwargs.setdefault("timeout", DEFAULT_TIMEOUT)
-    session = cache_and_return_session(endpoint_uri)
-    response = session.post(endpoint_uri, *args, **kwargs)
-    return response
-
-
-def make_post_request(
-    endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], *args: Any, **kwargs: Any
-) -> bytes:
-    response = get_response_from_post_request(endpoint_uri, data=data, *args, **kwargs)
-    response.raise_for_status()
-    return response.content
-
-
-def _close_evicted_sessions(evicted_sessions: List[requests.Session]) -> None:
-    for evicted_session in evicted_sessions:
-        evicted_session.close()
-        logger.debug(f"Closed evicted session: {evicted_session}")
-
-
-# --- async --- #
-
-
-_async_session_cache = SimpleCache()
-_async_session_cache_lock = threading.Lock()
-_async_session_pool = ThreadPoolExecutor(max_workers=1)
-
-
-async def async_cache_and_return_session(
-    endpoint_uri: URI,
-    session: Optional[ClientSession] = None,
-) -> ClientSession:
-    # cache key should have a unique thread identifier
-    cache_key = generate_cache_key(f"{threading.get_ident()}:{endpoint_uri}")
-
-    evicted_items = None
-    async with async_lock(_async_session_pool, _async_session_cache_lock):
-        if cache_key not in _async_session_cache:
-            if session is None:
-                session = ClientSession(raise_for_status=True)
-
-            cached_session, evicted_items = _async_session_cache.cache(
-                cache_key, session
-            )
-            logger.debug(f"Async session cached: {endpoint_uri}, {cached_session}")
-
-        else:
-            # get the cached session
-            cached_session = _async_session_cache.get_cache_entry(cache_key)
-            session_is_closed = cached_session.closed
-            session_loop_is_closed = cached_session._loop.is_closed()
-
-            warning = (
-                "Async session was closed"
-                if session_is_closed
-                else (
-                    "Loop was closed for async session"
-                    if session_loop_is_closed
-                    else None
-                )
-            )
-            if warning:
-                logger.debug(
-                    f"{warning}: {endpoint_uri}, {cached_session}. "
-                    f"Creating and caching a new async session for uri."
-                )
-
-                _async_session_cache._data.pop(cache_key)
-                if not session_is_closed:
-                    # if loop was closed but not the session, close the session
-                    await cached_session.close()
-                logger.debug(
-                    f"Async session closed and evicted from cache: {cached_session}"
-                )
-
-                # replace stale session with a new session at the cache key
-                _session = ClientSession(raise_for_status=True)
-                cached_session, evicted_items = _async_session_cache.cache(
-                    cache_key, _session
-                )
-                logger.debug(f"Async session cached: {endpoint_uri}, {cached_session}")
-
-    if evicted_items is not None:
-        # At this point the evicted sessions are already popped out of the cache and
-        # just stored in the `evicted_sessions` dict. So we can kick off a future task
-        # to close them and it should be safe to pop out of the lock here.
-        evicted_sessions = evicted_items.values()
-        for evicted_session in evicted_sessions:
-            logger.debug(
-                "Async session cache full. Session evicted from cache: "
-                f"{evicted_session}",
-            )
-        # Kick off a future task, in a separate thread, to close the evicted
-        # sessions. In the case that the cache filled very quickly and some
-        # sessions have been evicted before their original request has been made,
-        # we set the timer to a bit more than the `DEFAULT_TIMEOUT` for a call. This
-        # should make it so that any call from an evicted session can still be made
-        # before the session is closed.
-        threading.Timer(
-            DEFAULT_TIMEOUT + 0.1,
-            _async_close_evicted_sessions,
-            args=[evicted_sessions],
-        ).start()
-
-    return cached_session
-
-
-async def async_get_response_from_get_request(
-    endpoint_uri: URI, *args: Any, **kwargs: Any
-) -> ClientResponse:
-    kwargs.setdefault("timeout", ClientTimeout(DEFAULT_TIMEOUT))
-    session = await async_cache_and_return_session(endpoint_uri)
-    response = await session.get(endpoint_uri, *args, **kwargs)
-    return response
-
-
-async def async_json_make_get_request(
-    endpoint_uri: URI, *args: Any, **kwargs: Any
-) -> Dict[str, Any]:
-    response = await async_get_response_from_get_request(endpoint_uri, *args, **kwargs)
-    response.raise_for_status()
-    return await response.json()
-
-
-async def async_get_response_from_post_request(
-    endpoint_uri: URI, *args: Any, **kwargs: Any
-) -> ClientResponse:
-    kwargs.setdefault("timeout", ClientTimeout(DEFAULT_TIMEOUT))
-    session = await async_cache_and_return_session(endpoint_uri)
-    response = await session.post(endpoint_uri, *args, **kwargs)
-    return response
-
-
-async def async_make_post_request(
-    endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], *args: Any, **kwargs: Any
-) -> bytes:
-    response = await async_get_response_from_post_request(
-        endpoint_uri, data=data, *args, **kwargs
-    )
-    response.raise_for_status()
-    return await response.read()
-
-
-async def async_get_json_from_client_response(
-    response: ClientResponse,
-) -> Dict[str, Any]:
-    return await response.json()
-
-
-def _async_close_evicted_sessions(evicted_sessions: List[ClientSession]) -> None:
-    loop = asyncio.new_event_loop()
-
-    for evicted_session in evicted_sessions:
-        loop.run_until_complete(evicted_session.close())
-        logger.debug(f"Closed evicted async session: {evicted_session}")
-
-    if any(not evicted_session.closed for evicted_session in evicted_sessions):
-        logger.warning(
-            f"Some evicted async sessions were not properly closed: {evicted_sessions}"
-        )
-    loop.close()