def validate_attr_dict(self, attr_dict: Dict[str, str]) -> None:
"""
Validates that ContractType keys in attr_dict reference existing manifest ContractTypes.
"""
attr_dict_names = list(attr_dict.keys())
if not self.unlinked_references and not self.linked_references:
raise BytecodeLinkingError(
"Unable to validate attr dict, this contract has no linked/unlinked references."
)
unlinked_refs = self.unlinked_references or ({}, )
linked_refs = self.linked_references or ({}, )
all_link_refs = unlinked_refs + linked_refs
all_link_names = [ref["name"] for ref in all_link_refs if ref]
if set(attr_dict_names) != set(all_link_names):
raise BytecodeLinkingError(
"All link references must be defined when calling "
"`link_bytecode` on a contract factory.")
for address in attr_dict.values():
if not is_canonical_address(address):
raise BytecodeLinkingError(
f"Address: {address} as specified in the attr_dict is not "
"a valid canoncial address.")
def set_registry(self, address: Address) -> None:
"""
Sets the current registry used in ``web3.pm`` functions that read/write to an on-chain
registry. This method accepts checksummed/canonical addresses or ENS names. Addresses
must point to an on-chain instance of an ERC1319 registry implementation.
To use an ENS domain as the address, make sure a valid ENS instance set as ``web3.ens``.
* Parameters:
* ``address``: Address of on-chain Registry.
"""
if is_canonical_address(address) or is_checksum_address(address):
self.registry = SimpleRegistry(address, self.web3)
elif is_ens_name(address):
self._validate_set_ens()
addr_lookup = self.web3.ens.address(address)
if not addr_lookup:
raise NameNotFound(
"No address found after ENS lookup for name: {0}.".format(
address))
self.registry = SimpleRegistry(addr_lookup, self.web3)
else:
raise PMError(
"Expected a canonical/checksummed address or ENS name for the address, "
"instead received {0}.".format(type(address)))
def set_registry(self, address: Address) -> None:
"""
Sets the current registry used in ``web3.pm`` functions that read/write to an on-chain
registry. This method accepts checksummed/canonical addresses or ENS names. Addresses
must point to an instance of the Vyper Reference Registry implementation.
If you want to use a different registry implementation with ``web3.pm``, manually
set the ``web3.pm.registry`` attribute to any subclass of ``ERCRegistry``.
To use an ENS domain as the address, make sure a valid ENS instance set as ``web3.ens``.
* Parameters:
* ``address``: Address of on-chain Vyper Reference Registry.
"""
if is_canonical_address(address) or is_checksum_address(address):
canonical_address = to_canonical_address(address)
self.registry = VyperReferenceRegistry(canonical_address,
self.web3)
elif is_ens_name(address):
self._validate_set_ens()
addr_lookup = self.web3.ens.address(address)
if not addr_lookup:
raise NameNotFound(
"No address found after ENS lookup for name: {0}.".format(
address))
self.registry = VyperReferenceRegistry(
to_canonical_address(addr_lookup), self.web3)
else:
raise PMError(
"Expected a canonical/checksummed address or ENS name for the address, "
"instead received {0}.".format(type(address)))
def compute_leaf_hash(item: Item) -> bytes:
address, value = item
if not is_canonical_address(address):
raise ValueError("Address must be a canonical address")
if value < 0 or value >= 2**256:
raise ValueError("value is negative or too large")
return keccak(address + value.to_bytes(32, "big"))
def validate_address(address: Any) -> None:
"""
Raise a ValidationError if an address is not canonicalized.
"""
if not is_address(address):
raise ValidationError(f"Expected an address, got: {address}")
if not is_canonical_address(address):
raise ValidationError(
"Py-EthPM library only accepts canonicalized addresses. "
f"{address} is not in the accepted format.")
def apply_link_ref(offset: int, length: int, value: bytes, bytecode: bytes) -> bytes:
"""
Returns the new bytecode with `value` put into the location indicated by `offset` and `length`.
"""
try:
validate_empty_bytes(offset, length, bytecode)
except EthPMValidationError:
raise BytecodeLinkingError("Link references cannot be applied to bytecode")
address = value if is_canonical_address(value) else to_canonical_address(value)
new_bytes = (
# Ignore linting error b/c conflict b/w black & flake8
bytecode[:offset] + address + bytecode[offset + length:] # noqa: E201, E203
)
return new_bytes
def __init__(
self,
validator_proxy_contract,
validator_address,
poll_interval,
control_queue,
stop_validating_callback,
) -> None:
self.validator_proxy_contract = validator_proxy_contract
if not is_canonical_address(validator_address):
raise ValueError(
"Validator address must be given in canonical format")
self.validator_address = validator_address
self.poll_interval = poll_interval
self.control_queue = control_queue
self.stop_validating_callback = stop_validating_callback
def make_call_context(sender_address,
gas,
value=None,
gas_price=None,
data=None):
if not is_canonical_address(sender_address):
raise ValueError(
'sender_address should be provided in the canonical format')
if not (isinstance(gas, int) and gas > 0):
raise ValueError('gas should be provided as positive integer')
# Both 'from' and 'gas' are required in eth_tester
yield 'from', to_checksum_address(sender_address)
yield 'gas', gas
if value is not None:
yield 'value', value
if gas_price is not None:
yield 'gas_price', gas_price
if data is not None:
yield 'data', data
def make_call_context(sender_address: bytes,
gas: int,
value: int=None,
gas_price: int=None,
data: bytes=None) -> Generator[Tuple[str, Any], None, None]:
"""
Makes the context for message call.
"""
if not is_canonical_address(sender_address):
raise ValueError('sender_address should be provided in the canonical format')
if not (isinstance(gas, int) and gas > 0):
raise ValueError('gas should be provided as positive integer')
# Both 'from' and 'gas' are required in eth_tester
yield 'from', to_checksum_address(sender_address)
yield 'gas', gas
if value is not None:
yield 'value', value
if gas_price is not None:
yield 'gas_price', gas_price
if data is not None:
yield 'data', data
def test_configure_pfs(service_registry_address, private_keys, web3,
contract_manager):
chain_id = ChainID(int(web3.net.version))
service_registry, urls = deploy_service_registry_and_set_urls(
private_keys=private_keys,
web3=web3,
contract_manager=contract_manager,
service_registry_address=service_registry_address,
)
json_data = {
"price_info":
0,
"network_info": {
"chain_id":
chain_id,
"token_network_registry_address":
to_checksum_address(token_network_registry_address_test_default),
"user_deposit_address":
to_checksum_address(privatekey_to_address(private_keys[1])),
"confirmed_block": {
"number": 10
},
},
"message":
"This is your favorite pathfinding service",
"operator":
"John Doe",
"version":
"0.0.1",
"payment_address":
to_checksum_address(privatekey_to_address(private_keys[0])),
}
response = mocked_json_response(response_data=json_data)
# With local routing configure_pfs should raise assertion
with pytest.raises(AssertionError):
_ = configure_pfs_or_exit(
pfs_url="",
routing_mode=RoutingMode.LOCAL,
service_registry=service_registry,
node_network_id=chain_id,
token_network_registry_address=
token_network_registry_address_test_default,
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
# With private routing configure_pfs should raise assertion
with pytest.raises(AssertionError):
_ = configure_pfs_or_exit(
pfs_url="",
routing_mode=RoutingMode.PRIVATE,
service_registry=service_registry,
node_network_id=chain_id,
token_network_registry_address=
token_network_registry_address_test_default,
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
# Asking for auto address
# To make this deterministic we need to patch the random selection function
patch_random = patch("raiden.network.pathfinding.get_random_pfs",
return_value="http://foo")
with patch.object(requests, "get", return_value=response), patch_random:
config = configure_pfs_or_exit(
pfs_url=MATRIX_AUTO_SELECT_SERVER,
routing_mode=RoutingMode.PFS,
service_registry=service_registry,
node_network_id=chain_id,
token_network_registry_address=
token_network_registry_address_test_default,
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
assert config.url in urls
assert is_canonical_address(config.payment_address)
# Configuring a valid given address
given_address = "http://foo"
with patch.object(requests, "get", return_value=response):
config = configure_pfs_or_exit(
pfs_url=given_address,
routing_mode=RoutingMode.PFS,
service_registry=service_registry,
node_network_id=chain_id,
token_network_registry_address=
token_network_registry_address_test_default,
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
assert config.url == given_address
assert is_same_address(config.payment_address,
json_data["payment_address"])
assert config.price == json_data["price_info"]
# Bad address, should exit the program
bad_address = "http://badaddress"
with pytest.raises(RaidenError):
with patch.object(requests,
"get",
side_effect=requests.RequestException()):
# Configuring a given address
_ = configure_pfs_or_exit(
pfs_url=bad_address,
routing_mode=RoutingMode.PFS,
service_registry=service_registry,
node_network_id=chain_id,
token_network_registry_address=
token_network_registry_address_test_default,
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
# Addresses of token network registries of pfs and client conflict, should exit the client
response = mocked_json_response(response_data=json_data)
with pytest.raises(RaidenError):
with patch.object(requests, "get", return_value=response):
_ = configure_pfs_or_exit(
pfs_url="http://foo",
routing_mode=RoutingMode.PFS,
service_registry=service_registry,
node_network_id=chain_id,
token_network_registry_address=TokenNetworkRegistryAddress(
to_canonical_address(
"0x2222222222222222222222222222222222222221")),
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
# ChainIDs of pfs and client conflict, should exit the client
response = mocked_json_response(response_data=json_data)
with pytest.raises(RaidenError):
with patch.object(requests, "get", return_value=response):
configure_pfs_or_exit(
pfs_url="http://foo",
routing_mode=RoutingMode.PFS,
service_registry=service_registry,
node_network_id=ChainID(chain_id + 1),
token_network_registry_address=
token_network_registry_address_test_default,
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
def test_to_canonical_address_from_public_key(private_key):
address = private_key.public_key.to_canonical_address()
assert is_canonical_address(address)
assert is_same_address(address, ADDRESS)
def validate_canonical_address(value):
validate_bytes(value)
if not is_canonical_address(value):
raise ValidationError("Value must be a 20 byte string")
