def __init__(self, providers=empty, middlewares=None, modules=None, ens=empty, chain_id=100, hrp_type=None): self.manager = RequestManager(self, providers, middlewares) if providers: try: self.net_type = self.getAddressHrp except Exception as e: if not hrp_type: raise ValueError( "Failed to obtain hrp automatically,need to be passed in from outside,exception info:{}" .format(e)) else: self.net_type = hrp_type else: if not hrp_type: raise ValueError( "Offline mode needs to specify the network type and cannot be empty,parameter hrp_type must be specified" ) self.net_type = hrp_type if modules is None: modules = get_default_modules() for module_name, module_class in modules.items(): module_class.attach(self, module_name) # platon contract address self.ens = ens self.chain_id = chain_id
def test_add_duplicate_middleware(middleware_factory): mw = middleware_factory() with pytest.raises(ValueError): manager = RequestManager(None, BaseProvider(), middlewares=[mw, mw]) manager = RequestManager(None, BaseProvider(), middlewares=[]) manager.middleware_stack.add(mw) with pytest.raises(ValueError): manager.middleware_stack.add(mw) assert tuple(manager.middleware_stack) == (mw, )
def test_middleware_holds_state_across_requests(): provider = BaseProvider() manager = RequestManager(None, provider, middlewares=[stateful_middleware]) state_a = manager.request_blocking('test_statefulness', []) assert len(state_a) == 1 state_b = manager.request_blocking('test_statefulness', []) assert id(state_a) == id(state_b) assert len(state_b) == 2
def test_provider_property_setter_and_getter(): provider_a = BaseProvider() provider_b = BaseProvider() assert provider_a is not provider_b manager = RequestManager(None, provider_a) assert manager.providers[0] is provider_a manager.providers = provider_b assert manager.providers[0] is provider_b
def test_provider_property_setter_and_getter(middleware_factory): middleware_a = middleware_factory('middleware-A') middleware_b = middleware_factory('middleware-B') provider = DummyProvider() manager = RequestManager(None, provider, middlewares=[middleware_a, middleware_b]) response = manager.request_blocking('init', ['init']) assert response['method'] == 'init|middleware-A|middleware-B' assert response['params'] == ['init', 'middleware-A', 'middleware-B'] assert response['middlewares'] == ['middleware-B', 'middleware-A']
def __init__(self, providers=empty, middlewares=None, modules=None, ens=empty, chain_id=100): self.manager = RequestManager(self, providers, middlewares) if modules is None: modules = get_default_modules() for module_name, module_class in modules.items(): module_class.attach(self, module_name) if chain_id == 100: self.net_type = MIANNETHRP else: self.net_type = TESTNETHRP # platon contract address self.restrictingAddress = restricting[self.net_type] self.stakingAddress = staking[self.net_type] self.penaltyAddress = penalty[self.net_type] self.pipAddress = pipAddr[self.net_type] self.delegateRewardAddress = delegateReward[self.net_type] self.ens = ens self.chain_id = chain_id
def test_provider_property_setter_and_getter(middleware_factory): provider = BaseProvider() middleware_a = middleware_factory() middleware_b = middleware_factory() middleware_c = middleware_factory() assert middleware_a is not middleware_b assert middleware_a is not middleware_c manager = RequestManager(None, provider, middlewares=[]) assert tuple(manager.middleware_stack) == tuple() manager.middleware_stack.add(middleware_a) manager.middleware_stack.add(middleware_b) manager.middleware_stack.clear() assert tuple(manager.middleware_stack) == tuple() manager.middleware_stack.add(middleware_c) manager.middleware_stack.add(middleware_b) manager.middleware_stack.add(middleware_a) with pytest.raises(ValueError): manager.middleware_stack.add(middleware_b) assert tuple(manager.middleware_stack) == ( middleware_a, middleware_b, middleware_c, )
def test_bury_middleware(middleware_factory): mw1 = middleware_factory() mw2 = middleware_factory() mw3 = middleware_factory() manager = RequestManager(None, BaseProvider(), middlewares=[mw1, mw2]) manager.middleware_stack.inject(mw3, layer=0) assert tuple(manager.middleware_stack) == (mw1, mw2, mw3)
def test_add_middleware(middleware_factory): mw1 = middleware_factory() mw2 = middleware_factory() mw3 = middleware_factory() manager = RequestManager(None, BaseProvider(), middlewares=[mw1, mw2]) manager.middleware_stack.add(mw3) assert tuple(manager.middleware_stack) == (mw3, mw1, mw2)
def test_add_named_duplicate_middleware(middleware_factory): mw = middleware_factory() manager = RequestManager(None, BaseProvider(), middlewares=[(mw, 'the-name'), (mw, 'name2')]) assert tuple(manager.middleware_stack) == (mw, mw) manager.middleware_stack.clear() assert len(manager.middleware_stack) == 0 manager.middleware_stack.add(mw, 'name1') manager.middleware_stack.add(mw, 'name2') assert tuple(manager.middleware_stack) == (mw, mw)
def __init__(self, providers=empty, middlewares=None, modules=None, ens=empty, chain_id=101): self.manager = RequestManager(self, providers, middlewares) if modules is None: modules = get_default_modules() for module_name, module_class in modules.items(): module_class.attach(self, module_name) self.ens = ens self.chain_id = chain_id
def test_remove_middleware(middleware_factory): mw1 = middleware_factory() mw2 = middleware_factory() mw3 = middleware_factory() manager = RequestManager(None, BaseProvider(), middlewares=[mw1, mw2, mw3]) assert tuple(manager.middleware_stack) == (mw1, mw2, mw3) manager.middleware_stack.remove(mw2) assert tuple(manager.middleware_stack) == (mw1, mw3)
def test_bury_named_middleware(middleware_factory): mw1 = middleware_factory() mw2 = middleware_factory() mw3 = middleware_factory() manager = RequestManager(None, BaseProvider(), middlewares=[mw1, mw2]) manager.middleware_stack.inject(mw3, name='middleware3', layer=0) assert tuple(manager.middleware_stack) == (mw1, mw2, mw3) # make sure middleware was injected with correct name, by trying to remove # it by name. manager.middleware_stack.remove('middleware3') assert tuple(manager.middleware_stack) == (mw1, mw2)
def test_replace_middleware_without_name(middleware_factory): mw1 = middleware_factory() mw2 = middleware_factory() mw3 = middleware_factory() manager = RequestManager(None, BaseProvider(), middlewares=[mw1, mw2, mw3]) assert tuple(manager.middleware_stack) == (mw1, mw2, mw3) mw_replacement = middleware_factory() manager.middleware_stack.replace(mw2, mw_replacement) assert tuple(manager.middleware_stack) == (mw1, mw_replacement, mw3) manager.middleware_stack.remove(mw_replacement) assert tuple(manager.middleware_stack) == (mw1, mw3)
class Web3: # Providers HTTPProvider = HTTPProvider IPCProvider = IPCProvider TestRPCProvider = TestRPCProvider EthereumTesterProvider = EthereumTesterProvider WebsocketProvider = WebsocketProvider # Managers RequestManager = RequestManager # Iban Iban = Iban # Encoding and Decoding toBytes = staticmethod(to_bytes) toInt = staticmethod(to_int) toHex = staticmethod(to_hex) toText = staticmethod(to_text) # Currency Utility toWei = staticmethod(to_wei) fromWei = staticmethod(from_wei) analyzeReceipt = staticmethod(analyze) # Address Utility isAddress = staticmethod(is_address) isChecksumAddress = staticmethod(is_checksum_address) toChecksumAddress = staticmethod(to_checksum_address) def __init__(self, providers=empty, middlewares=None, modules=None, ens=empty, chain_id=100, hrp_type=None): self.manager = RequestManager(self, providers, middlewares) if providers: try: self.net_type = self.getAddressHrp except Exception as e: if not hrp_type: raise ValueError( "Failed to obtain hrp automatically,need to be passed in from outside,exception info:{}" .format(e)) else: self.net_type = hrp_type else: if not hrp_type: raise ValueError( "Offline mode needs to specify the network type and cannot be empty,parameter hrp_type must be specified" ) self.net_type = hrp_type if modules is None: modules = get_default_modules() for module_name, module_class in modules.items(): module_class.attach(self, module_name) # platon contract address self.ens = ens self.chain_id = chain_id @property def chainId(self): return self.chain_id @chainId.setter def chainId(self, chain_id): self.chain_id = chain_id @property def middleware_stack(self): return self.manager.middleware_stack @property def providers(self): return self.manager.providers @providers.setter def providers(self, providers): self.manager.providers = providers @staticmethod @apply_to_return_value(HexBytes) def sha3(primitive=None, text=None, hexstr=None): if isinstance(primitive, (bytes, int, type(None))): input_bytes = to_bytes(primitive, hexstr=hexstr, text=text) return keccak(input_bytes) raise TypeError( "You called sha3 with first arg %r and keywords %r. You must call it with one of " "these approaches: sha3(text='txt'), sha3(hexstr='0x747874'), " "sha3(b'\\x74\\x78\\x74'), or sha3(0x747874)." % (primitive, { 'text': text, 'hexstr': hexstr })) @combomethod def soliditySha3(cls, abi_types, values): """ Executes sha3 (keccak256) exactly as Solidity does. Takes list of abi_types as inputs -- `[uint24, int8[], bool]` and list of corresponding values -- `[20, [-1, 5, 0], True]` """ if len(abi_types) != len(values): raise ValueError( "Length mismatch between provided abi types and values. Got " "{0} types and {1} values.".format(len(abi_types), len(values))) if isinstance(cls, type): w3 = None else: w3 = cls normalized_values = map_abi_data([abi_ens_resolver(w3)], abi_types, values) hex_string = add_0x_prefix(''.join( remove_0x_prefix(hex_encode_abi_type(abi_type, value)) for abi_type, value in zip(abi_types, normalized_values))) return cls.sha3(hexstr=hex_string) def isConnected(self): for provider in self.providers: if provider.isConnected(): return True else: return False @property def ens(self): if self._ens is empty: return ENS.fromWeb3(self) else: return self._ens @property def getAddressHrp(self): return self.manager.request_blocking("platon_getAddressHrp", []) @ens.setter def ens(self, new_ens): self._ens = new_ens def pubkey_to_address(self, pubkey): return pubkey.to_bech32_address(self.net_type)
def test_add_named_middleware(middleware_factory): mw = middleware_factory() manager = RequestManager(None, BaseProvider(), middlewares=[(mw, 'the-name')]) assert len(manager.middleware_stack) == 1 assert tuple(manager.middleware_stack) == (mw, )