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, )
