class Net(Module): _listening: Method[Callable[[], bool]] = Method( RPC.net_listening, mungers=[default_root_munger], ) _peer_count: Method[Callable[[], int]] = Method( RPC.net_peerCount, mungers=[default_root_munger], ) _version: Method[Callable[[], str]] = Method( RPC.net_version, mungers=[default_root_munger], ) @property def chainId(self) -> NoReturn: raise DeprecationWarning( "This method has been deprecated in EIP 1474.") @property def listening(self) -> bool: return self._listening() @property def peer_count(self) -> int: return self._peer_count() @property def version(self) -> str: return self._version() # # Deprecated Methods # peerCount = DeprecatedMethod(peer_count, 'peerCount', 'peer_count') # type: ignore
class Eth(BaseEth, Module): account = Account() _default_block: BlockIdentifier = "latest" defaultContractFactory: Type[ Union[Contract, ConciseContract, ContractCaller]] = Contract # noqa: E704,E501 iban = Iban def namereg(self) -> NoReturn: raise NotImplementedError() def icapNamereg(self) -> NoReturn: raise NotImplementedError() _protocol_version: Method[Callable[[], str]] = Method( RPC.eth_protocolVersion, mungers=None, ) @property def protocol_version(self) -> str: warnings.warn( "This method has been deprecated in some clients.", category=DeprecationWarning, ) return self._protocol_version() @property def protocolVersion(self) -> str: warnings.warn( 'protocolVersion is deprecated in favor of protocol_version', category=DeprecationWarning, ) return self.protocol_version is_syncing: Method[Callable[[], Union[SyncStatus, bool]]] = Method( RPC.eth_syncing, mungers=None, ) @property def syncing(self) -> Union[SyncStatus, bool]: return self.is_syncing() @property def coinbase(self) -> ChecksumAddress: return self.get_coinbase() is_mining: Method[Callable[[], bool]] = Method( RPC.eth_mining, mungers=None, ) @property def mining(self) -> bool: return self.is_mining() get_hashrate: Method[Callable[[], int]] = Method( RPC.eth_hashrate, mungers=None, ) @property def hashrate(self) -> int: return self.get_hashrate() @property def gas_price(self) -> Wei: return self._gas_price() @property def gasPrice(self) -> Wei: warnings.warn( 'gasPrice is deprecated in favor of gas_price', category=DeprecationWarning, ) return self.gas_price get_accounts: Method[Callable[[], Tuple[ChecksumAddress]]] = Method( RPC.eth_accounts, mungers=None, ) @property def accounts(self) -> Tuple[ChecksumAddress]: return self.get_accounts() @property def block_number(self) -> BlockNumber: return self.get_block_number() @property def blockNumber(self) -> BlockNumber: warnings.warn( 'blockNumber is deprecated in favor of block_number', category=DeprecationWarning, ) return self.block_number _chain_id: Method[Callable[[], int]] = Method( RPC.eth_chainId, mungers=None, ) @property def chain_id(self) -> int: return self._chain_id() @property def chainId(self) -> int: warnings.warn( 'chainId is deprecated in favor of chain_id', category=DeprecationWarning, ) return self.chain_id """ property default_account """ @property def default_account(self) -> Union[ChecksumAddress, Empty]: return self._default_account @default_account.setter def default_account(self, account: Union[ChecksumAddress, Empty]) -> None: self._default_account = account @property def defaultAccount(self) -> Union[ChecksumAddress, Empty]: warnings.warn( 'defaultAccount is deprecated in favor of default_account', category=DeprecationWarning, ) return self._default_account @defaultAccount.setter def defaultAccount(self, account: Union[ChecksumAddress, Empty]) -> None: warnings.warn( 'defaultAccount is deprecated in favor of default_account', category=DeprecationWarning, ) self._default_account = account """ property default_block """ @property def default_block(self) -> BlockIdentifier: return self._default_block @default_block.setter def default_block(self, value: BlockIdentifier) -> None: self._default_block = value @property def defaultBlock(self) -> BlockIdentifier: warnings.warn( 'defaultBlock is deprecated in favor of default_block', category=DeprecationWarning, ) return self._default_block @defaultBlock.setter def defaultBlock(self, value: BlockIdentifier) -> None: warnings.warn( 'defaultBlock is deprecated in favor of default_block', category=DeprecationWarning, ) self._default_block = value def block_id_munger( self, account: Union[Address, ChecksumAddress, ENS], block_identifier: Optional[BlockIdentifier] = None ) -> Tuple[Union[Address, ChecksumAddress, ENS], BlockIdentifier]: if block_identifier is None: block_identifier = self.default_block return (account, block_identifier) get_balance: Method[Callable[..., Wei]] = Method( RPC.eth_getBalance, mungers=[block_id_munger], ) def get_storage_at_munger( self, account: Union[Address, ChecksumAddress, ENS], position: int, block_identifier: Optional[BlockIdentifier] = None ) -> Tuple[Union[Address, ChecksumAddress, ENS], int, BlockIdentifier]: if block_identifier is None: block_identifier = self.default_block return (account, position, block_identifier) get_storage_at: Method[Callable[..., HexBytes]] = Method( RPC.eth_getStorageAt, mungers=[get_storage_at_munger], ) def get_proof_munger( self, account: Union[Address, ChecksumAddress, ENS], positions: Sequence[int], block_identifier: Optional[BlockIdentifier] = None ) -> Tuple[Union[Address, ChecksumAddress, ENS], Sequence[int], Optional[BlockIdentifier]]: if block_identifier is None: block_identifier = self.default_block return (account, positions, block_identifier) get_proof: Method[Callable[[ Tuple[Union[Address, ChecksumAddress, ENS], Sequence[int], Optional[BlockIdentifier]] ], MerkleProof]] = Method( RPC.eth_getProof, mungers=[get_proof_munger], ) get_code: Method[Callable[..., HexBytes]] = Method(RPC.eth_getCode, mungers=[block_id_munger]) def get_block(self, block_identifier: BlockIdentifier, full_transactions: bool = False) -> BlockData: return self._get_block(block_identifier, full_transactions) """ `eth_getBlockTransactionCountByHash` `eth_getBlockTransactionCountByNumber` """ get_block_transaction_count: Method[Callable[ [BlockIdentifier], int]] = Method( method_choice_depends_on_args=select_method_for_block_identifier( if_predefined=RPC.eth_getBlockTransactionCountByNumber, if_hash=RPC.eth_getBlockTransactionCountByHash, if_number=RPC.eth_getBlockTransactionCountByNumber, ), mungers=[default_root_munger]) """ `eth_getUncleCountByBlockHash` `eth_getUncleCountByBlockNumber` """ get_uncle_count: Method[Callable[[BlockIdentifier], int]] = Method( method_choice_depends_on_args=select_method_for_block_identifier( if_predefined=RPC.eth_getUncleCountByBlockNumber, if_hash=RPC.eth_getUncleCountByBlockHash, if_number=RPC.eth_getUncleCountByBlockNumber, ), mungers=[default_root_munger]) """ `eth_getUncleByBlockHashAndIndex` `eth_getUncleByBlockNumberAndIndex` """ get_uncle_by_block: Method[Callable[ [BlockIdentifier, int], Uncle]] = Method( method_choice_depends_on_args=select_method_for_block_identifier( if_predefined=RPC.eth_getUncleByBlockNumberAndIndex, if_hash=RPC.eth_getUncleByBlockHashAndIndex, if_number=RPC.eth_getUncleByBlockNumberAndIndex, ), mungers=[default_root_munger]) def get_transaction(self, transaction_hash: _Hash32) -> TxData: return self._get_transaction(transaction_hash) def getTransactionFromBlock(self, block_identifier: BlockIdentifier, transaction_index: int) -> NoReturn: """ Alias for the method getTransactionByBlock Deprecated to maintain naming consistency with the json-rpc API """ raise DeprecationWarning( "This method has been deprecated as of EIP 1474.") get_transaction_by_block: Method[Callable[ [BlockIdentifier, int], TxData]] = Method( method_choice_depends_on_args=select_method_for_block_identifier( if_predefined=RPC.eth_getTransactionByBlockNumberAndIndex, if_hash=RPC.eth_getTransactionByBlockHashAndIndex, if_number=RPC.eth_getTransactionByBlockNumberAndIndex, ), mungers=[default_root_munger]) @deprecated_for("wait_for_transaction_receipt") def waitForTransactionReceipt(self, transaction_hash: _Hash32, timeout: int = 120, poll_latency: float = 0.1) -> TxReceipt: return self.wait_for_transaction_receipt(transaction_hash, timeout, poll_latency) def wait_for_transaction_receipt(self, transaction_hash: _Hash32, timeout: int = 120, poll_latency: float = 0.1) -> TxReceipt: try: return wait_for_transaction_receipt(self.web3, transaction_hash, timeout, poll_latency) except Timeout: raise TimeExhausted( "Transaction {} is not in the chain, after {} seconds".format( to_hex(transaction_hash), timeout, )) get_transaction_receipt: Method[Callable[[_Hash32], TxReceipt]] = Method( RPC.eth_getTransactionReceipt, mungers=[default_root_munger]) get_transaction_count: Method[Callable[..., Nonce]] = Method( RPC.eth_getTransactionCount, mungers=[block_id_munger], ) @deprecated_for("replace_transaction") def replaceTransaction(self, transaction_hash: _Hash32, new_transaction: TxParams) -> HexBytes: return self.replace_transaction(transaction_hash, new_transaction) def replace_transaction(self, transaction_hash: _Hash32, new_transaction: TxParams) -> HexBytes: current_transaction = get_required_transaction(self.web3, transaction_hash) return replace_transaction(self.web3, current_transaction, new_transaction) # todo: Update Any to stricter kwarg checking with TxParams # https://github.com/python/mypy/issues/4441 @deprecated_for("modify_transaction") def modifyTransaction(self, transaction_hash: _Hash32, **transaction_params: Any) -> HexBytes: return self.modify_transaction(transaction_hash, **transaction_params) def modify_transaction(self, transaction_hash: _Hash32, **transaction_params: Any) -> HexBytes: assert_valid_transaction_params(cast(TxParams, transaction_params)) current_transaction = get_required_transaction(self.web3, transaction_hash) current_transaction_params = extract_valid_transaction_params( current_transaction) new_transaction = merge(current_transaction_params, transaction_params) return replace_transaction(self.web3, current_transaction, new_transaction) def send_transaction(self, transaction: TxParams) -> HexBytes: return self._send_transaction(transaction) send_raw_transaction: Method[Callable[[Union[HexStr, bytes]], HexBytes]] = Method( RPC.eth_sendRawTransaction, mungers=[default_root_munger], ) def sign_munger( self, account: Union[Address, ChecksumAddress, ENS], data: Union[int, bytes] = None, hexstr: HexStr = None, text: str = None ) -> Tuple[Union[Address, ChecksumAddress, ENS], HexStr]: message_hex = to_hex(data, hexstr=hexstr, text=text) return (account, message_hex) sign: Method[Callable[..., HexStr]] = Method( RPC.eth_sign, mungers=[sign_munger], ) sign_transaction: Method[Callable[[TxParams], SignedTx]] = Method( RPC.eth_signTransaction, mungers=[default_root_munger], ) sign_typed_data: Method[Callable[..., HexStr]] = Method( RPC.eth_signTypedData, mungers=[default_root_munger], ) def call_munger( self, transaction: TxParams, block_identifier: Optional[BlockIdentifier] = None, state_override: Optional[CallOverrideParams] = None, ) -> Union[Tuple[TxParams, BlockIdentifier], Tuple[ TxParams, BlockIdentifier, CallOverrideParams]]: # noqa-E501 # TODO: move to middleware if 'from' not in transaction and is_checksum_address( self.default_account): transaction = assoc(transaction, 'from', self.default_account) # TODO: move to middleware if block_identifier is None: block_identifier = self.default_block if state_override is None: return (transaction, block_identifier) else: return (transaction, block_identifier, state_override) call: Method[Callable[..., Union[bytes, bytearray]]] = Method(RPC.eth_call, mungers=[call_munger]) def estimate_gas( self, transaction: TxParams, block_identifier: Optional[BlockIdentifier] = None) -> Wei: return self._estimate_gas(transaction, block_identifier) def filter_munger( self, filter_params: Optional[Union[str, FilterParams]] = None, filter_id: Optional[HexStr] = None ) -> Union[List[FilterParams], List[HexStr], List[str]]: if filter_id and filter_params: raise TypeError( "Ambiguous invocation: provide either a `filter_params` or a `filter_id` argument. " "Both were supplied.") if isinstance(filter_params, dict): return [filter_params] elif is_string(filter_params): if filter_params in ['latest', 'pending']: return [filter_params] else: raise ValueError( "The filter API only accepts the values of `pending` or " "`latest` for string based filters") elif filter_id and not filter_params: return [filter_id] else: raise TypeError( "Must provide either filter_params as a string or " "a valid filter object, or a filter_id as a string " "or hex.") filter: Method[Callable[..., Any]] = Method( method_choice_depends_on_args=select_filter_method( if_new_block_filter=RPC.eth_newBlockFilter, if_new_pending_transaction_filter=RPC. eth_newPendingTransactionFilter, if_new_filter=RPC.eth_newFilter, ), mungers=[filter_munger], ) get_filter_changes: Method[Callable[[HexStr], List[LogReceipt]]] = Method( RPC.eth_getFilterChanges, mungers=[default_root_munger]) get_filter_logs: Method[Callable[[HexStr], List[LogReceipt]]] = Method( RPC.eth_getFilterLogs, mungers=[default_root_munger]) get_logs: Method[Callable[[FilterParams], List[LogReceipt]]] = Method( RPC.eth_getLogs, mungers=[default_root_munger]) submit_hashrate: Method[Callable[[int, _Hash32], bool]] = Method( RPC.eth_submitHashrate, mungers=[default_root_munger], ) submit_work: Method[Callable[[int, _Hash32, _Hash32], bool]] = Method( RPC.eth_submitWork, mungers=[default_root_munger], ) uninstall_filter: Method[Callable[[HexStr], bool]] = Method( RPC.eth_uninstallFilter, mungers=[default_root_munger], ) @overload def contract(self, address: None = None, **kwargs: Any) -> Type[Contract]: ... # noqa: E704,E501 @overload # noqa: F811 def contract(self, address: Union[Address, ChecksumAddress, ENS], **kwargs: Any) -> Contract: ... # noqa: E704,E501 def contract( # noqa: F811 self, address: Optional[Union[Address, ChecksumAddress, ENS]] = None, **kwargs: Any) -> Union[Type[Contract], Contract]: ContractFactoryClass = kwargs.pop('ContractFactoryClass', self.defaultContractFactory) ContractFactory = ContractFactoryClass.factory(self.web3, **kwargs) if address: return ContractFactory(address) else: return ContractFactory @deprecated_for("set_contract_factory") def setContractFactory( self, contractFactory: Type[Union[Contract, ConciseContract, ContractCaller]] ) -> None: return self.set_contract_factory(contractFactory) def set_contract_factory( self, contractFactory: Type[Union[Contract, ConciseContract, ContractCaller]] ) -> None: self.defaultContractFactory = contractFactory def getCompilers(self) -> NoReturn: raise DeprecationWarning( "This method has been deprecated as of EIP 1474.") get_work: Method[Callable[[], List[HexBytes]]] = Method( RPC.eth_getWork, mungers=None, ) @deprecated_for("generate_gas_price") def generateGasPrice( self, transaction_params: Optional[TxParams] = None) -> Optional[Wei]: return self._generate_gas_price(transaction_params) def generate_gas_price( self, transaction_params: Optional[TxParams] = None) -> Optional[Wei]: return self._generate_gas_price(transaction_params) @deprecated_for("set_gas_price_strategy") def setGasPriceStrategy(self, gas_price_strategy: GasPriceStrategy) -> None: return self.set_gas_price_strategy(gas_price_strategy) # Deprecated Methods getBalance = DeprecatedMethod(get_balance, 'getBalance', 'get_balance') getStorageAt = DeprecatedMethod(get_storage_at, 'getStorageAt', 'get_storage_at') getBlock = DeprecatedMethod(get_block, 'getBlock', 'get_block') # type: ignore getBlockTransactionCount = DeprecatedMethod(get_block_transaction_count, 'getBlockTransactionCount', 'get_block_transaction_count') getCode = DeprecatedMethod(get_code, 'getCode', 'get_code') getProof = DeprecatedMethod(get_proof, 'getProof', 'get_proof') getTransaction = DeprecatedMethod( get_transaction, # type: ignore 'getTransaction', 'get_transaction') getTransactionByBlock = DeprecatedMethod(get_transaction_by_block, 'getTransactionByBlock', 'get_transaction_by_block') getTransactionCount = DeprecatedMethod(get_transaction_count, 'getTransactionCount', 'get_transaction_count') getUncleByBlock = DeprecatedMethod(get_uncle_by_block, 'getUncleByBlock', 'get_uncle_by_block') getUncleCount = DeprecatedMethod(get_uncle_count, 'getUncleCount', 'get_uncle_count') sendTransaction = DeprecatedMethod( send_transaction, # type: ignore 'sendTransaction', 'send_transaction') signTransaction = DeprecatedMethod(sign_transaction, 'signTransaction', 'sign_transaction') signTypedData = DeprecatedMethod(sign_typed_data, 'signTypedData', 'sign_typed_data') submitHashrate = DeprecatedMethod(submit_hashrate, 'submitHashrate', 'submit_hashrate') submitWork = DeprecatedMethod(submit_work, 'submitWork', 'submit_work') getLogs = DeprecatedMethod(get_logs, 'getLogs', 'get_logs') estimateGas = DeprecatedMethod(estimate_gas, 'estimateGas', 'estimate_gas') # type: ignore sendRawTransaction = DeprecatedMethod(send_raw_transaction, 'sendRawTransaction', 'send_raw_transaction') getTransactionReceipt = DeprecatedMethod(get_transaction_receipt, 'getTransactionReceipt', 'get_transaction_receipt') uninstallFilter = DeprecatedMethod(uninstall_filter, 'uninstallFilter', 'uninstall_filter') getFilterLogs = DeprecatedMethod(get_filter_logs, 'getFilterLogs', 'get_filter_logs') getFilterChanges = DeprecatedMethod(get_filter_changes, 'getFilterChanges', 'get_filter_changes') getWork = DeprecatedMethod(get_work, 'getWork', 'get_work')
start_rpc: Method[ServerConnection] = Method( RPC.admin_startRPC, mungers=[admin_start_params_munger], ) start_ws: Method[ServerConnection] = Method( RPC.admin_startWS, mungers=[admin_start_params_munger], ) stop_rpc: Method[Callable[[], bool]] = Method( RPC.admin_stopRPC, mungers=None, ) stop_ws: Method[Callable[[], bool]] = Method( RPC.admin_stopWS, mungers=None, ) # # Deprecated Methods # addPeer = DeprecatedMethod(add_peer, 'addPeer', 'add_peer') nodeInfo = DeprecatedMethod(node_info, 'nodeInfo', 'node_info') startRPC = DeprecatedMethod(start_rpc, 'startRPC', 'start_rpc') stopRPC = DeprecatedMethod(stop_rpc, 'stopRPC', 'stop_rpc') startWS = DeprecatedMethod(start_ws, 'startWS', 'start_ws') stopWS = DeprecatedMethod(stop_ws, 'stopWS', 'stop_ws')
class Parity(Module): """ https://paritytech.github.io/wiki/JSONRPC-parity-module """ _default_block: BlockIdentifier = "latest" personal: ParityPersonal enode: Method[Callable[[], str]] = Method( RPC.parity_enode, mungers=None, ) """ property default_block """ @property def default_block(self) -> BlockIdentifier: return self._default_block @default_block.setter def default_block(self, value: BlockIdentifier) -> None: self._default_block = value @property def defaultBlock(self) -> BlockIdentifier: warnings.warn( 'defaultBlock is deprecated in favor of default_block', category=DeprecationWarning, ) return self._default_block @defaultBlock.setter def defaultBlock(self, value: BlockIdentifier) -> None: warnings.warn( 'defaultBlock is deprecated in favor of default_block', category=DeprecationWarning, ) self._default_block = value def list_storage_keys_munger( self, address: Union[Address, ChecksumAddress, ENS, Hash32], quantity: int, hash_: Hash32, block_identifier: Optional[BlockIdentifier] = None, ) -> Tuple[Union[Address, ChecksumAddress, ENS, Hash32], int, Hash32, BlockIdentifier]: if block_identifier is None: block_identifier = self.default_block return (address, quantity, hash_, block_identifier) list_storage_keys: Method[Callable[..., List[Hash32]]] = Method( RPC.parity_listStorageKeys, mungers=[list_storage_keys_munger], ) net_peers: Method[Callable[[], ParityNetPeers]] = Method(RPC.parity_netPeers, mungers=None) add_reserved_peer: Method[Callable[[EnodeURI], bool]] = Method( RPC.parity_addReservedPeer, mungers=[default_root_munger], ) def trace_replay_transaction_munger( self, block_identifier: Union[_Hash32, BlockIdentifier], mode: ParityTraceMode = ['trace'] ) -> Tuple[Union[BlockIdentifier, _Hash32], ParityTraceMode]: return (block_identifier, mode) trace_replay_transaction: Method[Callable[..., ParityBlockTrace]] = Method( RPC.trace_replayTransaction, mungers=[trace_replay_transaction_munger], ) trace_replay_block_transactions: Method[Callable[ ..., List[ParityBlockTrace]]] = Method( RPC.trace_replayBlockTransactions, mungers=[trace_replay_transaction_munger]) trace_block: Method[Callable[[BlockIdentifier], List[ParityBlockTrace]]] = Method( RPC.trace_block, mungers=[default_root_munger], ) trace_filter: Method[Callable[[ParityFilterParams], List[ParityFilterTrace]]] = Method( RPC.trace_filter, mungers=[default_root_munger], ) trace_transaction: Method[Callable[[_Hash32], List[ParityFilterTrace]]] = Method( RPC.trace_transaction, mungers=[default_root_munger], ) def trace_call_munger( self, transaction: TxParams, mode: ParityTraceMode = ['trace'], block_identifier: Optional[BlockIdentifier] = None ) -> Tuple[TxParams, ParityTraceMode, BlockIdentifier]: # TODO: move to middleware if 'from' not in transaction and is_checksum_address( self.web3.eth.default_account): transaction = assoc(transaction, 'from', self.web3.eth.default_account) # TODO: move to middleware if block_identifier is None: block_identifier = self.default_block return (transaction, mode, block_identifier) trace_call: Method[Callable[..., ParityBlockTrace]] = Method( RPC.trace_call, mungers=[trace_call_munger], ) def trace_transactions_munger(self, raw_transaction: HexStr, mode: ParityTraceMode = ['trace'] ) -> Tuple[HexStr, ParityTraceMode]: return (raw_transaction, mode) trace_raw_transaction: Method[Callable[..., ParityBlockTrace]] = Method( RPC.trace_rawTransaction, mungers=[trace_transactions_munger], ) set_mode: Method[Callable[[ParityMode], bool]] = Method( RPC.parity_setMode, mungers=[default_root_munger], ) mode: Method[Callable[[], ParityMode]] = Method(RPC.parity_mode, mungers=None) # Deprecated Methods addReservedPeer = DeprecatedMethod(add_reserved_peer, 'addReservedPeer', 'add_reserved_peer') listStorageKeys = DeprecatedMethod(list_storage_keys, 'listStorageKeys', 'list_storage_keys') netPeers = DeprecatedMethod(net_peers, 'netPeers', 'net_peers') setMode = DeprecatedMethod(set_mode, 'setMode', 'set_mode') traceBlock = DeprecatedMethod(trace_block, 'traceBlock', 'trace_block') traceCall = DeprecatedMethod(trace_call, 'traceCall', 'trace_call') traceFilter = DeprecatedMethod(trace_filter, 'traceFilter', 'trace_filter') traceRawTransaction = DeprecatedMethod(trace_raw_transaction, 'traceRawTransaction', 'trace_raw_transaction') traceReplayTransaction = DeprecatedMethod(trace_replay_transaction, 'traceReplayTransaction', 'trace_replay_transaction') traceReplayBlockTransactions = DeprecatedMethod( trace_replay_block_transactions, 'traceReplayBlockTransactions', 'trace_replay_block_transactions') traceTransaction = DeprecatedMethod(trace_transaction, 'traceTransaction', 'trace_transaction')
subscribe: Method[Callable[[ShhMessageFilter], ShhSubscriptionID]] = Method( RPC.shh_subscribe, mungers=[default_root_munger], ) unsubscribe: Method[Callable[[ShhSubscriptionID], bool]] = Method( RPC.shh_unsubscribe, mungers=[default_root_munger], ) # DeprecatedMethods setMaxMessageSize = DeprecatedMethod( set_max_message_size, 'setMaxMessageSize', 'set_max_message_size') setMinPoW = DeprecatedMethod(set_min_pow, 'setMinPoW', 'set_min_pow') markTrustedPeer = DeprecatedMethod(mark_trusted_peer, 'markTrustedPeer', 'mark_trusted_peer') newKeyPair = DeprecatedMethod(new_key_pair, 'newKeyPair', 'new_key_pair') addPrivateKey = DeprecatedMethod(add_private_key, 'addPrivateKey', 'add_private_key') deleteKeyPair = DeprecatedMethod(delete_key_pair, 'deleteKeyPair', 'delete_key_pair') deleteKey = DeprecatedMethod(delete_key, 'deleteKey', 'delete_key') hasKeyPair = DeprecatedMethod(has_key_pair, 'hasKeyPair', 'has_key_pair') getPublicKey = DeprecatedMethod(get_public_key, 'getPublicKey', 'get_public_key') getPrivateKey = DeprecatedMethod(get_private_key, 'getPrivateKey', 'get_private_key') newSymKey = DeprecatedMethod(new_sym_key, 'newSymKey', 'new_sym_key') addSymKey = DeprecatedMethod(add_sym_key, 'addSymKey', 'add_sym_key') generateSymKeyFromPassword = DeprecatedMethod( generate_sym_key_from_password, 'generateSymKeyFromPassword',
from typing import ( Callable, ) from web3._utils.rpc_abi import ( RPC, ) from web3.method import ( DeprecatedMethod, Method, default_root_munger, ) listening: Method[Callable[[], bool]] = Method( RPC.net_listening, mungers=[default_root_munger], ) peer_count: Method[Callable[[], int]] = Method( RPC.net_peerCount, mungers=[default_root_munger], ) version: Method[Callable[[], str]] = Method( RPC.net_version, mungers=[default_root_munger], ) # # Deprecated Methods # peerCount = DeprecatedMethod(peer_count, 'peerCount', 'peer_count')
sign: Method[Callable[[str, ChecksumAddress, Optional[str]], HexStr]] = Method( RPC.personal_sign, mungers=[default_root_munger], ) sign_typed_data: Method[Callable[[Dict[str, Any], ChecksumAddress, str], HexStr]] = Method( RPC.personal_signTypedData, mungers=[default_root_munger], ) ec_recover: Method[Callable[[str, HexStr], ChecksumAddress]] = Method( RPC.personal_ecRecover, mungers=[default_root_munger], ) # # Deprecated Methods # importRawKey = DeprecatedMethod(import_raw_key, 'importRawKey', 'import_raw_key') newAccount = DeprecatedMethod(new_account, 'newAccount', 'new_account') listAccounts = DeprecatedMethod(list_accounts, 'listAccounts', 'list_accounts') sendTransaction = DeprecatedMethod(send_transaction, 'sendTransaction', 'send_transaction') lockAccount = DeprecatedMethod(lock_account, 'lockAccount', 'lock_account') unlockAccount = DeprecatedMethod(unlock_account, 'unlockAccount', 'unlock_account') signTypedData = DeprecatedMethod(sign_typed_data, 'signTypedData', 'sign_typed_data') ecRecover = DeprecatedMethod(ec_recover, 'ecRecover', 'ec_recover')
start: Method[Callable[[int], bool]] = Method( RPC.miner_start, mungers=[default_root_munger], ) stop: Method[Callable[[], bool]] = Method( RPC.miner_stop, mungers=None, ) start_auto_dag: Method[Callable[[], bool]] = Method( RPC.miner_startAutoDag, mungers=None, ) stop_auto_dag: Method[Callable[[], bool]] = Method( RPC.miner_stopAutoDag, mungers=None, ) # # Deprecated Methods # makeDag = DeprecatedMethod(make_dag, 'makeDag', 'make_dag') setExtra = DeprecatedMethod(set_extra, 'setExtra', 'set_extra') setEtherbase = DeprecatedMethod(set_etherbase, 'setEtherbase', 'set_etherbase') setGasPrice = DeprecatedMethod(set_gas_price, 'setGasPrice', 'set_gas_price') startAutoDag = DeprecatedMethod(start_auto_dag, 'startAutoDag', 'start_auto_dag') stopAutoDag = DeprecatedMethod(stop_auto_dag, 'stopAutoDag', 'stop_auto_dag')