def test_format_dict_error():
with pytest.raises(ValueError) as exc_info:
apply_formatters_to_dict(
{'myfield': int},
{'myfield': 'a'},
)
with pytest.raises(ValueError) as exc_info:
eth_utils.apply_formatters_to_dict(
{'myfield': int},
{'myfield': 'a'},
)
assert 'myfield' in str(exc_info.value)
def _expect(post_state: Dict[str, Any], networks: Any,
transaction: TransactionDict, filler: Dict[str,
Any]) -> Dict[str, Any]:
test_name = get_test_name(filler)
test = filler[test_name]
test_update: Dict[str, Dict[Any, Any]] = {test_name: {}}
pre_state = test.get("pre", {})
post_state = normalize_state(post_state or {})
defaults = {
address: {
"balance": 0,
"nonce": 0,
"code": b"",
"storage": {},
}
for address in post_state
}
result = deep_merge(defaults, pre_state, normalize_state(post_state))
new_expect = {"result": result}
if transaction is not None:
transaction = normalize_transaction(
merge(get_default_transaction(networks), transaction))
if "transaction" not in test:
transaction_group = apply_formatters_to_dict(
{
"data": wrap_in_list,
"gasLimit": wrap_in_list,
"value": wrap_in_list,
}, transaction)
indexes = {
index_key: 0
for transaction_key, index_key in [
("gasLimit", "gas"),
("value", "value"),
("data", "data"),
] if transaction_key in transaction_group
}
else:
transaction_group, indexes = add_transaction_to_group(
test["transaction"], transaction)
new_expect = assoc(new_expect, "indexes", indexes)
test_update = assoc_in(test_update, [test_name, "transaction"],
transaction_group)
if networks is not None:
networks = normalize_networks(networks)
new_expect = assoc(new_expect, "networks", networks)
existing_expects = test.get("expect", [])
expect = existing_expects + [new_expect]
test_update = assoc_in(test_update, [test_name, "expect"], expect)
return deep_merge(filler, test_update)
def normalizer(d: Dict[Any, Any]) -> Dict[str, Any]:
keys = set(d.keys())
missing_keys = required_set_form - keys
superfluous_keys = keys - all_keys
if missing_keys:
raise KeyError("Missing required keys: {}".format(", ".join(missing_keys)))
if superfluous_keys:
raise KeyError("Superfluous keys: {}".format(", ".join(superfluous_keys)))
return apply_formatters_to_dict(formatters, d)
def sign_transaction(self, transaction_dict: dict) -> HexBytes:
formatters = {
'nonce': Web3.toHex,
'gasPrice': Web3.toHex,
'gas': Web3.toHex,
'value': Web3.toHex,
'chainId': Web3.toHex,
'from': to_checksum_address
}
transaction_dict = apply_formatters_to_dict(formatters,
transaction_dict)
signed = self.__ipc_request("account_signTransaction",
transaction_dict)
return HexBytes(signed.raw)
def __new__(mcs, name, bases, namespace, normalizers=None):
all_bases = set(concat(base.__mro__ for base in bases))
all_keys = set(concat(base.__dict__.keys() for base in all_bases))
for key in namespace:
verify_attr(name, key, all_keys)
if normalizers:
processed_namespace = apply_formatters_to_dict(
normalizers,
namespace,
)
else:
processed_namespace = namespace
return super().__new__(mcs, name, bases, processed_namespace)
def sign_transaction(self, transaction_dict: dict) -> HexBytes:
formatters = {
'nonce': Web3.toHex,
'gasPrice': Web3.toHex,
'gas': Web3.toHex,
'value': Web3.toHex,
'chainId': Web3.toHex,
'from': to_checksum_address
}
# Workaround for contract creation TXs
if transaction_dict['to'] == b'':
transaction_dict['to'] = None
elif transaction_dict['to']:
formatters['to'] = to_checksum_address
formatted_transaction = apply_formatters_to_dict(
formatters, transaction_dict)
signed = self.__ipc_request("account_signTransaction",
formatted_transaction)
return HexBytes(signed.raw)
def __new__( # type: ignore
mcs,
name: str,
bases: Tuple[type],
namespace: Dict[str, Any],
normalizers: Optional[Dict[str, Any]] = None
) -> Type['PropertyCheckingFactory']:
all_bases = set(concat(base.__mro__ for base in bases))
all_keys = set(concat(base.__dict__.keys() for base in all_bases))
for key in namespace:
verify_attr(name, key, all_keys)
if normalizers:
processed_namespace = apply_formatters_to_dict(
normalizers,
namespace,
)
else:
processed_namespace = namespace
return super().__new__(mcs, name, bases, processed_namespace)
def test_apply_formatters_to_dict(formatter, value, expected):
assert eth_utils.apply_formatters_to_dict(formatter, value) == expected
mapper = apply_formatters_to_dict(formatter)
assert mapper(value) == expected
def normalize_transaction_dict(
transaction_dict: Dict[str, str]) -> Dict[str, Any]:
normalized_dict = apply_formatters_to_dict(TRANSACTION_NORMALIZER,
transaction_dict)
return merge(SAFE_TRANSACTION_DEFAULTS, normalized_dict)
def test_format_dict_error():
with pytest.raises(ValueError) as exc_info:
apply_formatters_to_dict({"myfield": int}, {"myfield": "a"})
with pytest.raises(ValueError) as exc_info:
eth_utils.apply_formatters_to_dict({"myfield": int}, {"myfield": "a"})
assert "myfield" in str(exc_info.value)
