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

web3/types.py

@@ -5,10 +5,13 @@ from typing import (
     Coroutine,
     Dict,
     List,
+    Literal,
     NewType,
     Optional,
     Sequence,
+    Tuple,
     Type,
+    TypedDict,
     TypeVar,
     Union,
 )
@@ -24,34 +27,39 @@ from hexbytes import (
     HexBytes,
 )
 
-from web3._utils.compat import (
-    Literal,
-    NotRequired,
-    TypedDict,
-)
-from web3._utils.function_identifiers import (
+from web3._utils.abi_element_identifiers import (
     FallbackFn,
     ReceiveFn,
 )
+from web3._utils.compat import (
+    NotRequired,
+)
 
 if TYPE_CHECKING:
-    from web3.contract.async_contract import AsyncContractFunction  # noqa: F401
-    from web3.contract.contract import ContractFunction  # noqa: F401
+    from web3.contract.async_contract import (  # noqa: F401
+        AsyncContractEvent,
+        AsyncContractFunction,
+    )
+    from web3.contract.contract import (  # noqa: F401
+        ContractEvent,
+        ContractFunction,
+    )
     from web3.main import (  # noqa: F401
         AsyncWeb3,
         Web3,
     )
 
 
-TReturn = TypeVar("TReturn")
+TFunc = TypeVar("TFunc", bound=Callable[..., Any])
 TParams = TypeVar("TParams")
+TReturn = TypeVar("TReturn")
 TValue = TypeVar("TValue")
 
 BlockParams = Literal["latest", "earliest", "pending", "safe", "finalized"]
 BlockIdentifier = Union[BlockParams, BlockNumber, Hash32, HexStr, HexBytes, int]
 LatestBlockParam = Literal["latest"]
 
-FunctionIdentifier = Union[str, Type[FallbackFn], Type[ReceiveFn]]
+ABIElementIdentifier = Union[str, Type[FallbackFn], Type[ReceiveFn]]
 
 # bytes, hexbytes, or hexstr representing a 32 byte hash
 _Hash32 = Union[Hash32, HexBytes, HexStr]
@@ -73,46 +81,6 @@ class AccessListEntry(TypedDict):
 AccessList = NewType("AccessList", Sequence[AccessListEntry])
 
 
-# todo: move these to eth_typing once web3 is type hinted
-class ABIEventParams(TypedDict, total=False):
-    indexed: bool
-    name: str
-    type: str
-
-
-class ABIEvent(TypedDict, total=False):
-    anonymous: bool
-    inputs: Sequence["ABIEventParams"]
-    name: str
-    type: Literal["event"]
-
-
-class ABIFunctionComponents(TypedDict, total=False):
-    components: Sequence["ABIFunctionComponents"]
-    name: str
-    type: str
-
-
-class ABIFunctionParams(TypedDict, total=False):
-    components: Sequence["ABIFunctionComponents"]
-    name: str
-    type: str
-
-
-class ABIFunction(TypedDict, total=False):
-    constant: bool
-    inputs: Sequence["ABIFunctionParams"]
-    name: str
-    outputs: Sequence["ABIFunctionParams"]
-    payable: bool
-    stateMutability: Literal["pure", "view", "nonpayable", "payable"]
-    type: Literal["function", "constructor", "fallback", "receive"]
-
-
-ABIElement = Union[ABIFunction, ABIEvent]
-ABI = Sequence[Union[ABIFunction, ABIEvent]]
-
-
 class EventData(TypedDict):
     address: ChecksumAddress
     args: Dict[str, Any]
@@ -135,6 +103,7 @@ TxData = TypedDict(
     "TxData",
     {
         "accessList": AccessList,
+        "blobVersionedHashes": Sequence[HexBytes],
         "blockHash": HexBytes,
         "blockNumber": BlockNumber,
         "chainId": int,
@@ -142,6 +111,7 @@ TxData = TypedDict(
         "from": ChecksumAddress,
         "gas": int,
         "gasPrice": Wei,
+        "maxFeePerBlobGas": Wei,
         "maxFeePerGas": Wei,
         "maxPriorityFeePerGas": Wei,
         "hash": HexBytes,
@@ -163,6 +133,8 @@ TxData = TypedDict(
 TxParams = TypedDict(
     "TxParams",
     {
+        "accessList": AccessList,
+        "blobVersionedHashes": Sequence[Union[str, HexStr, bytes, HexBytes]],
         "chainId": int,
         "data": Union[bytes, HexStr],
         # addr or ens
@@ -170,6 +142,7 @@ TxParams = TypedDict(
         "gas": int,
         # legacy pricing
         "gasPrice": Wei,
+        "maxFeePerBlobGas": Union[str, Wei],
         # dynamic fee pricing
         "maxFeePerGas": Union[str, Wei],
         "maxPriorityFeePerGas": Union[str, Wei],
@@ -183,15 +156,11 @@ TxParams = TypedDict(
 )
 
 
-WithdrawalData = TypedDict(
-    "WithdrawalData",
-    {
-        "index": int,
-        "validator_index": int,
-        "address": ChecksumAddress,
-        "amount": Gwei,
-    },
-)
+class WithdrawalData(TypedDict):
+    index: int
+    validator_index: int
+    address: ChecksumAddress
+    amount: Gwei
 
 
 class BlockData(TypedDict, total=False):
@@ -218,6 +187,9 @@ class BlockData(TypedDict, total=False):
     uncles: Sequence[HexBytes]
     withdrawals: Sequence[WithdrawalData]
     withdrawalsRoot: HexBytes
+    parentBeaconBlockRoot: HexBytes
+    blobGasUsed: int
+    excessBlobGas: int
 
     # ExtraDataToPOAMiddleware replaces extraData w/ proofOfAuthorityData
     proofOfAuthorityData: HexBytes
@@ -290,8 +262,15 @@ EthSubscriptionParams = Union[
 RPCId = Optional[Union[int, str]]
 
 
+class RPCRequest(TypedDict, total=False):
+    id: RPCId
+    jsonrpc: Literal["2.0"]
+    method: RPCEndpoint
+    params: Any
+
+
 class RPCResponse(TypedDict, total=False):
-    error: Union[RPCError, str]
+    error: RPCError
     id: RPCId
     jsonrpc: Literal["2.0"]
     result: Any
@@ -301,11 +280,19 @@ class RPCResponse(TypedDict, total=False):
     params: EthSubscriptionParams
 
 
+EthSubscriptionResult = Union[
+    BlockData,  # newHeads
+    TxData,  # newPendingTransactions, full_transactions=True
+    HexBytes,  # newPendingTransactions, full_transactions=False
+    LogReceipt,  # logs
+    SyncProgress,  # syncing
+    GethSyncingSubscriptionResult,  # geth syncing
+]
+
+
 class FormattedEthSubscriptionResponse(TypedDict):
     subscription: HexStr
-    result: Union[
-        BlockData, TxData, LogReceipt, SyncProgress, GethSyncingSubscriptionResult
-    ]
+    result: EthSubscriptionResult
 
 
 class CreateAccessListResponse(TypedDict):
@@ -314,7 +301,11 @@ class CreateAccessListResponse(TypedDict):
 
 
 MakeRequestFn = Callable[[RPCEndpoint, Any], RPCResponse]
+MakeBatchRequestFn = Callable[[List[Tuple[RPCEndpoint, Any]]], List[RPCResponse]]
 AsyncMakeRequestFn = Callable[[RPCEndpoint, Any], Coroutine[Any, Any, RPCResponse]]
+AsyncMakeBatchRequestFn = Callable[
+    [List[Tuple[RPCEndpoint, Any]]], Coroutine[Any, Any, List[RPCResponse]]
+]
 
 
 class FormattersDict(TypedDict, total=False):
@@ -338,17 +329,12 @@ class FeeHistory(TypedDict):
     reward: List[List[Wei]]
 
 
-StateOverrideParams = TypedDict(
-    "StateOverrideParams",
-    {
-        "balance": Optional[Wei],
-        "nonce": Optional[int],
-        "code": Optional[Union[bytes, HexStr]],
-        "state": Optional[Dict[HexStr, HexStr]],
-        "stateDiff": Optional[Dict[HexStr, HexStr]],
-    },
-    total=False,
-)
+class StateOverrideParams(TypedDict, total=False):
+    balance: Optional[Wei]
+    nonce: Optional[int]
+    code: Optional[Union[bytes, HexStr]]
+    state: Optional[Dict[HexStr, HexStr]]
+    stateDiff: Optional[Dict[HexStr, HexStr]]
 
 
 StateOverride = Dict[ChecksumAddress, StateOverrideParams]
@@ -381,6 +367,8 @@ TxReceipt = TypedDict(
     },
 )
 
+BlockReceipts = List[TxReceipt]
+
 
 class SignedTx(TypedDict, total=False):
     raw: bytes
@@ -502,6 +490,84 @@ class TxPoolStatus(TypedDict, total=False):
     queued: int
 
 
+#
+# debug types
+#
+class TraceConfig(TypedDict, total=False):
+    disableStorage: bool
+    disableStack: bool
+    enableMemory: bool
+    enableReturnData: bool
+    tracer: str
+    tracerConfig: Dict[str, Any]
+    timeout: int
+
+
+class CallTraceLog(TypedDict):
+    address: ChecksumAddress
+    data: HexBytes
+    topics: Sequence[HexBytes]
+    position: int
+
+
+# syntax b/c "from" keyword not allowed w/ class construction
+CallTrace = TypedDict(
+    "CallTrace",
+    {
+        "type": str,
+        "from": ChecksumAddress,
+        "to": ChecksumAddress,
+        "value": Wei,
+        "gas": int,
+        "gasUsed": int,
+        "input": HexBytes,
+        "output": HexBytes,
+        "error": str,
+        "revertReason": str,
+        "calls": Sequence["CallTrace"],
+        "logs": Sequence[CallTraceLog],
+    },
+    total=False,
+)
+
+
+class TraceData(TypedDict, total=False):
+    balance: int
+    nonce: int
+    code: str
+    storage: Dict[str, str]
+
+
+class DiffModeTrace(TypedDict):
+    post: Dict[ChecksumAddress, TraceData]
+    pre: Dict[ChecksumAddress, TraceData]
+
+
+PrestateTrace = Dict[ChecksumAddress, TraceData]
+
+
+# 4byte tracer returns something like:
+# { '0x27dc297e-128' : 1 }
+# which is: { 4byte signature - calldata size : # of occurrences of key }
+FourByteTrace = Dict[str, int]
+
+
+class StructLog(TypedDict):
+    pc: int
+    op: str
+    gas: int
+    gasCost: int
+    depth: int
+    stack: List[HexStr]
+
+
+class OpcodeTrace(TypedDict, total=False):
+    gas: int
+    failed: bool
+    returnValue: str
+    structLogs: List[StructLog]
+
+
 #
 # web3.geth types
 #
@@ -516,6 +582,7 @@ class GethWallet(TypedDict):
 # Contract types
 
 TContractFn = TypeVar("TContractFn", "ContractFunction", "AsyncContractFunction")
+TContractEvent = TypeVar("TContractEvent", "ContractEvent", "AsyncContractEvent")
 
 
 # Tracing types

web3/utils/__init__.py

@@ -3,17 +3,76 @@ NOTE: This is a public utility module. Any changes to these utility methods woul
 classify as breaking changes.
 """
 
-from .abi import (  # NOQA
+from eth_utils.abi import (
+    abi_to_signature,
+    collapse_if_tuple,
+    event_abi_to_log_topic,
+    event_signature_to_log_topic,
+    filter_abi_by_name,
+    filter_abi_by_type,
+    function_abi_to_4byte_selector,
+    function_signature_to_4byte_selector,
     get_abi_input_names,
+    get_abi_input_types,
     get_abi_output_names,
+    get_abi_output_types,
+    get_aligned_abi_inputs,
+    get_all_event_abis,
+    get_all_function_abis,
+    get_normalized_abi_inputs,
+)
+from .abi import (  # NOQA
+    check_if_arguments_can_be_encoded,
+    get_abi_element_info,
+    get_abi_element,
+    get_event_abi,
+    get_event_log_topics,
+    log_topic_to_bytes,
 )
-from .address import get_create_address  # NOQA
-from .async_exception_handling import (  # NOQA
+from .address import (
+    get_create_address,
+)
+from .async_exception_handling import (
     async_handle_offchain_lookup,
 )
-from .caching import (  # NOQA
+from .caching import (
+    RequestCacheValidationThreshold,
     SimpleCache,
 )
-from .exception_handling import (  # NOQA
+from .exception_handling import (
     handle_offchain_lookup,
 )
+from .subscriptions import (
+    EthSubscription,
+)
+
+__all__ = [
+    "abi_to_signature",
+    "collapse_if_tuple",
+    "event_abi_to_log_topic",
+    "event_signature_to_log_topic",
+    "filter_abi_by_name",
+    "filter_abi_by_type",
+    "function_abi_to_4byte_selector",
+    "function_signature_to_4byte_selector",
+    "get_abi_input_names",
+    "get_abi_input_types",
+    "get_abi_output_names",
+    "get_abi_output_types",
+    "get_aligned_abi_inputs",
+    "get_all_event_abis",
+    "get_all_function_abis",
+    "get_normalized_abi_inputs",
+    "check_if_arguments_can_be_encoded",
+    "get_abi_element_info",
+    "get_abi_element",
+    "get_event_abi",
+    "get_event_log_topics",
+    "log_topic_to_bytes",
+    "get_create_address",
+    "async_handle_offchain_lookup",
+    "RequestCacheValidationThreshold",
+    "SimpleCache",
+    "EthSubscription",
+    "handle_offchain_lookup",
+]