def normalize_fixture(fixture):
normalized_fixture = {
'in':
tuple((
decode_hex(key) if is_0x_prefixed(key) else force_bytes(key),
(decode_hex(value) if is_0x_prefixed(value) else force_bytes(value)
) if value is not None else None,
) for key, value in (fixture['in'].items(
) if isinstance(fixture['in'], dict) else fixture['in'])),
'root':
decode_hex(fixture['root'])
}
return normalized_fixture
def pack(*args) -> bytes:
def format_int(value, size):
assert isinstance(value, int)
assert isinstance(size, int)
if value >= 0:
return decode_hex('{:x}'.format(value).zfill(size // 4))
else:
return decode_hex('{:x}'.format((1 << size) + value))
msg = b''
for arg in args:
assert arg is not None
if isinstance(arg, bytes):
msg += arg
elif isinstance(arg, str):
if is_0x_prefixed(arg):
msg += decode_hex(arg)
else:
msg += arg.encode()
elif isinstance(arg, bool):
msg += format_int(int(arg), 8)
elif isinstance(arg, int):
msg += format_int(arg, 256)
elif isinstance(arg, tuple):
msg += format_int(arg[0], arg[1])
else:
raise ValueError('Unsupported type: {}.'.format(type(arg)))
return msg
def first_pass_check_address_arr(cls, address_param_lst, param_name, base_param_type, conversion_errors):
error_flag = False
ret = address_param_lst
for idx, each_addr in enumerate(address_param_lst):
each_addr = str(each_addr)
ret[idx] = "0x"
if not eth_utils.is_0x_prefixed(each_addr):
if param_name not in conversion_errors:
conversion_errors[param_name] = {"message": [], "failed_indexes": []}
e_m = "Expected type: address. Supplied argument {0} not a hexadecimal value".format(each_addr)
conversion_errors[param_name]["message"].append(e_m)
conversion_errors[param_name]["failed_indexes"].append(idx)
error_flag = True
else:
if not eth_utils.is_address(each_addr):
if param_name not in conversion_errors:
conversion_errors[param_name] = {"message": [], "failed_indexes": []}
e_m = "Expected type: address. Supplied argument {0} is not a valid Ethereum address".format(
each_addr)
conversion_errors[param_name]["message"].append(e_m)
conversion_errors[param_name]["failed_indexes"].append(idx)
error_flag = True
else:
ret[idx] = each_addr
return (ret, error_flag)
def validate_block_header(ctx, param, value):
if is_hex(value) and is_0x_prefixed(value):
return decode_hex(value)
else:
raise click.BadParameter(
f"A block header parameter seems to be not well structured: {value}"
)
def pack(*args) -> bytes:
"""
Simulates Solidity's sha3 packing. Integers can be passed as tuples where the second tuple
element specifies the variable's size in bits, e.g.:
sha3((5, 32))
would be equivalent to Solidity's
sha3(uint32(5))
Default size is 256.
"""
def format_int(value, size):
assert isinstance(value, int)
assert isinstance(size, int)
if value >= 0:
return decode_hex('{:x}'.format(value).zfill(size // 4))
else:
return decode_hex('{:x}'.format((1 << size) + value))
msg = b''
for arg in args:
assert arg
if isinstance(arg, bytes):
msg += arg
elif isinstance(arg, str):
if is_0x_prefixed(arg):
msg += decode_hex(arg)
else:
msg += arg.encode()
elif isinstance(arg, int):
msg += format_int(arg, 256)
elif isinstance(arg, tuple):
msg += format_int(arg[0], arg[1])
else:
raise ValueError('Unsupported type: {}.'.format(type(arg)))
return msg
def to_decimal(value=None, hexstr=None, text=None):
"""
Converts value to it's decimal representation in string
"""
assert_one_val(value, hexstr=hexstr, text=text)
if hexstr is not None:
return int(hexstr, 16)
elif text is not None:
return int(text)
elif is_string(value):
if bytes != str and isinstance(value, bytes):
return to_decimal(hexstr=to_hex(value))
elif is_0x_prefixed(value) or _is_prefixed(value, '-0x'):
warnings.warn(
DeprecationWarning(
"Sending a hex string in the first position has been deprecated. Please use "
"toDecimal(hexstr='%s') instead." % value))
return to_decimal(hexstr=value)
else:
try:
return int(value)
except ValueError:
return to_decimal(hexstr=to_hex(value))
else:
return int(value)
async def test_checkout_consumer():
checkout = CheckoutFactory()
checkout.store.accepted_currencies.add(checkout.payment_order.currency)
communicator = WebsocketCommunicator(application,
f"checkout/{checkout.id}")
ok, protocol_or_error = await communicator.connect()
assert ok, "Failed to connect"
tx = TransactionFactory()
await sync_to_async(blockchain_payment_sent.send)(
sender=EthereumToken,
amount=checkout.payment_order.as_token_amount,
recipient=checkout.payment_order.payment_method.wallet.address,
transaction_hash=tx.hash,
)
response = await communicator.receive_json_from()
assert "event" in response
assert "voucher" in response
assert "identifier" in response
assert "payment_method" in response
assert is_0x_prefixed(response["identifier"])
assert response["payment_method"] == PAYMENT_METHODS.blockchain
assert response["event"] == "payment.sent"
def pack(*args) -> bytes:
"""
Simulates Solidity's sha3 packing. Integers can be passed as tuples where the second tuple
element specifies the variable's size in bits, e.g.:
sha3((5, 32))
would be equivalent to Solidity's
sha3(uint32(5))
Default size is 256.
"""
def format_int(value, size):
assert isinstance(value, int)
assert isinstance(size, int)
if value >= 0:
return decode_hex('{:x}'.format(value).zfill(size // 4))
else:
return decode_hex('{:x}'.format((1 << size) + value))
msg = b''
for arg in args:
assert arg
if isinstance(arg, bytes):
msg += arg
elif isinstance(arg, str):
if is_0x_prefixed(arg):
msg += decode_hex(arg)
else:
msg += arg.encode()
elif isinstance(arg, int):
msg += format_int(arg, 256)
elif isinstance(arg, tuple):
msg += format_int(arg[0], arg[1])
else:
raise ValueError('Unsupported type: {}.'.format(type(arg)))
return msg
def to_hex(value):
"""
Auto converts any supported value into it's hex representation.
"""
if is_boolean(value):
return "0x1" if value else "0x0"
if is_dict(value):
return encode_hex(json.dumps(value, sort_keys=True))
if is_string(value):
if is_prefixed(value, '-0x'):
return from_decimal(value)
elif is_0x_prefixed(value):
return value
else:
return encode_hex(value)
if is_integer(value):
return from_decimal(value)
raise TypeError(
"Unsupported type: '{0}'. Must be one of Boolean, Dictionary, String, "
"or Integer.".format(repr(type(value)))
)
def to_int(value):
if is_0x_prefixed(value):
if len(value) == 2:
return 0
else:
return int(value, 16)
else:
return int(value)
def test_initcode_simple_contract(runner):
result = runner.invoke(main, "initcode OtherContract -d testcontracts")
print(result.output)
assert result.exit_code == 0
transaction_hash = result.output.splitlines()[-1]
assert is_hex(transaction_hash)
assert is_0x_prefixed(transaction_hash)
def is_ens_name(value):
if not isinstance(value, str):
return False
elif is_hex_address(value):
return False
elif is_0x_prefixed(value) and is_hex(value):
return False
else:
return ENS.is_valid_name(value)
def is_ens_name(value):
if not isinstance(value, str):
return False
elif is_hex_address(value):
return False
elif is_0x_prefixed(value) and is_hex(value):
return False
else:
return ENS.is_valid_name(value)
def test_initcode_with_constructor_argument(runner, key_password):
result = runner.invoke(main,
"initcode TestContract 123456 -d testcontracts",
input=key_password)
assert result.exit_code == 0
transaction_hash = result.output.splitlines()[-1]
assert is_hex(transaction_hash)
assert is_0x_prefixed(transaction_hash)
def from_decimal(value):
"""
Converts numeric value to its hex representation
"""
if is_string(value):
if is_0x_prefixed(value) or _is_prefixed(value, '-0x'):
value = int(value, 16)
else:
value = int(value)
return to_hex(value)
def validate_abi_value(abi_type, value):
"""
Helper function for validating a value against the expected abi_type
Note: abi_type 'bytes' must either be python3 'bytes' object or ''
"""
if is_array_type(abi_type) and is_list_like(value):
# validate length
specified_length = length_of_array_type(abi_type)
if specified_length is not None:
if specified_length < 1:
raise TypeError(
"Invalid abi-type: {abi_type}. Length of fixed sized arrays"
"must be greater than 0."
.format(abi_type=abi_type)
)
if specified_length != len(value):
raise TypeError(
"The following array length does not the length specified"
"by the abi-type, {abi_type}: {value}"
.format(abi_type=abi_type, value=value)
)
# validate sub_types
sub_type = sub_type_of_array_type(abi_type)
for v in value:
validate_abi_value(sub_type, v)
return
elif is_bool_type(abi_type) and is_boolean(value):
return
elif is_uint_type(abi_type) and is_integer(value) and value >= 0:
return
elif is_int_type(abi_type) and is_integer(value):
return
elif is_address_type(abi_type):
validate_address(value)
return
elif is_bytes_type(abi_type):
if sys.version_info.major >= 3 and is_bytes(value):
return
elif is_string(value):
if is_0x_prefixed(value):
return
else:
raise TypeError(
"ABI values of abi-type 'bytes' must be either"
"a python3 'bytes' object or an '0x' prefixed string."
)
elif is_string_type(abi_type) and is_string(value):
return
raise TypeError(
"The following abi value is not a '{abi_type}': {value}"
.format(abi_type=abi_type, value=value)
)
def validate_abi_value(abi_type: TypeStr, value: Any) -> None:
"""
Helper function for validating a value against the expected abi_type
Note: abi_type 'bytes' must either be python3 'bytes' object or ''
"""
if is_array_type(abi_type) and is_list_like(value):
# validate length
specified_length = length_of_array_type(abi_type)
if specified_length is not None:
if specified_length < 1:
raise TypeError(
"Invalid abi-type: {abi_type}. Length of fixed sized arrays"
"must be greater than 0."
.format(abi_type=abi_type)
)
if specified_length != len(value):
raise TypeError(
"The following array length does not the length specified"
"by the abi-type, {abi_type}: {value}"
.format(abi_type=abi_type, value=value)
)
# validate sub_types
sub_type = sub_type_of_array_type(abi_type)
for v in value:
validate_abi_value(sub_type, v)
return
elif is_bool_type(abi_type) and is_boolean(value):
return
elif is_uint_type(abi_type) and is_integer(value) and value >= 0:
return
elif is_int_type(abi_type) and is_integer(value):
return
elif is_address_type(abi_type):
validate_address(value)
return
elif is_bytes_type(abi_type):
if is_bytes(value):
return
elif is_string(value):
if is_0x_prefixed(value):
return
else:
raise TypeError(
"ABI values of abi-type 'bytes' must be either"
"a python3 'bytes' object or an '0x' prefixed string."
)
elif is_string_type(abi_type) and is_string(value):
return
raise TypeError(
"The following abi value is not a '{abi_type}': {value}"
.format(abi_type=abi_type, value=value)
)
def to_int(value):
"""
Robust to integer conversion, handling hex values, string representations,
and special cases like `0x`.
"""
if is_0x_prefixed(value):
if len(value) == 2:
return 0
else:
return int(value, 16)
else:
return int(value)
def to_int(value):
"""
Robust to integer conversion, handling hex values, string representations,
and special cases like `0x`.
"""
if is_0x_prefixed(value):
if len(value) == 2:
return 0
else:
return int(value, 16)
else:
return int(value)
def to_python(self, value):
if not is_0x_prefixed(value):
raise InvalidEndpoint('Not a valid hex address, 0x prefix missing.')
if not is_checksum_address(value):
raise InvalidEndpoint('Not a valid EIP55 encoded address.')
try:
value = to_canonical_address(value)
except ValueError:
raise InvalidEndpoint('Could not decode hex.')
return value
def _deserialize(self, value, attr, data, **kwargs): # pylint: disable=unused-argument
if not is_0x_prefixed(value):
self.fail("missing_prefix")
try:
value = to_bytes(hexstr=value)
except binascii.Error:
self.fail("invalid_data")
if len(value) != SECRETHASH_LENGTH:
self.fail("invalid_size")
return value
def to_decimal(value):
"""
Converts value to it's decimal representation in string
"""
if is_string(value):
if is_0x_prefixed(value) or is_prefixed(value, '-0x'):
value = int(value, 16)
else:
value = int(value)
else:
value = int(value)
return value
def to_decimal(value):
"""
Converts value to it's decimal representation in string
"""
if is_string(value):
if is_0x_prefixed(value) or is_prefixed(value, '-0x'):
value = int(value, 16)
else:
value = int(value)
else:
value = int(value)
return value
def to_python(value):
if not is_0x_prefixed(value):
raise InvalidEndpoint("Not a valid hex address, 0x prefix missing.")
if not is_checksum_address(value):
raise InvalidEndpoint("Not a valid EIP55 encoded address.")
try:
value = to_canonical_address(value)
except ValueError:
raise InvalidEndpoint("Could not decode hex.")
return value
def to_python(self, value): # pylint: disable=no-self-use
if not is_0x_prefixed(value):
raise InvalidEndpoint('Not a valid hex address, 0x prefix missing.')
if not is_checksum_address(value):
raise InvalidEndpoint('Not a valid EIP55 encoded address.')
try:
value = to_canonical_address(value)
except ValueError:
raise InvalidEndpoint('Could not decode hex.')
return value
def address_checksum_and_decode(addr: str) -> Address:
""" Accepts a string address and turns it into binary.
Makes sure that the string address provided starts is 0x prefixed and
checksummed according to EIP55 specification
"""
if not is_0x_prefixed(addr):
raise InvalidChecksummedAddress("Address must be 0x prefixed")
if not is_checksum_address(addr):
raise InvalidChecksummedAddress("Address must be EIP55 checksummed")
return to_canonical_address(addr)
def deserialize_address_helper(self, value, attr, data): # pylint: disable=unused-argument
if not is_0x_prefixed(value):
self.fail("missing_prefix")
if not is_checksum_address(value):
self.fail("invalid_checksum")
try:
value = to_canonical_address(value)
except ValueError:
self.fail("invalid_data")
if len(value) != 20:
self.fail("invalid_size")
return value
def from_decimal(value):
"""
Converts numeric value to it's hex representation
"""
if is_string(value):
if is_0x_prefixed(value) or is_prefixed(value, '-0x'):
value = int(value, 16)
else:
value = int(value)
# python2 longs end up with an `L` hanging off the end of their hexidecimal
# representation.
result = hex(value).rstrip('L')
return result
def test_send_transaction_to_contract_find_duplicated_function_by_argument_length(
runner, test_contract_address, test_contract_name):
result = runner.invoke(
main,
(f"transact -d testcontracts --jsonrpc test --gas-price 1 --contract-address {test_contract_address} "
f"-- {test_contract_name} duplicatedDifferentArgumentLength 1"),
)
assert result.exit_code == 0
transaction_hash = result.output.splitlines()[-1]
assert is_hex(transaction_hash)
assert is_0x_prefixed(transaction_hash)
def test_send_transaction_to_contract(runner, test_contract_address,
test_contract_name):
result = runner.invoke(
main,
(f"transact -d testcontracts --jsonrpc test --gas-price 1 --contract-address {test_contract_address} "
f"-- {test_contract_name} set 1"),
)
assert result.exit_code == 0
transaction_hash = result.output.splitlines()[-1]
assert is_hex(transaction_hash)
assert is_0x_prefixed(transaction_hash)
def normalize_int(value):
"""
Robust to integer conversion, handling hex values, string representations,
and special cases like `0x`.
"""
if is_bytes(value):
return big_endian_to_int(value)
if is_hex(value) and is_0x_prefixed(value):
if len(value) == 2:
return 0
else:
return int(value, 16)
else:
return int(value)
def from_decimal(value):
"""
Converts numeric value to it's hex representation
"""
if is_string(value):
if is_0x_prefixed(value) or is_prefixed(value, '-0x'):
value = int(value, 16)
else:
value = int(value)
# python2 longs end up with an `L` hanging off the end of their hexidecimal
# representation.
result = hex(value).rstrip('L')
return result
def address_checksum_and_decode(addr: str) -> typing.Address:
""" Accepts a string address and turns it into binary.
Makes sure that the string address provided starts is 0x prefixed and
checksummed according to EIP55 specification
"""
if not is_0x_prefixed(addr):
raise InvalidAddress('Address must be 0x prefixed')
if not is_checksum_address(addr):
raise InvalidAddress('Address must be EIP55 checksummed')
addr_bytes = decode_hex(addr)
assert len(addr_bytes) in (20, 0)
return typing.Address(addr_bytes)
def first_pass_check_byte(cls, single_param, param_name, param_type, conversion_errors):
error_flag = False
if eth_utils.is_0x_prefixed(single_param):
pc = eth_utils.remove_0x_prefix(single_param)
pc_to_bytes = bytes.fromhex(pc)
ret = pc_to_bytes
else:
try:
ret = single_param.encode('utf-8')
except:
conversion_errors[param_name] = "Expected type: {0}. Supplied argument not a valid byte object.".format(
param_type)
error_flag = True
ret = "".encode('utf-8')
return (ret, error_flag)
def address_checksum_and_decode(addr: str) -> Address:
""" Accepts a string address and turns it into binary.
Makes sure that the string address provided starts is 0x prefixed and
checksummed according to EIP55 specification
"""
if not is_0x_prefixed(addr):
raise InvalidAddress("Address must be 0x prefixed")
if not is_checksum_address(addr):
raise InvalidAddress("Address must be EIP55 checksummed")
addr_bytes = decode_hex(addr)
assert len(addr_bytes) in (20, 0)
return Address(addr_bytes)
def inputPostFormatter(post):
"""
Formats the input of a whisper post and converts all values to HEX
"""
post["ttl"] = from_decimal(post["ttl"])
post["workToProve"] = from_decimal(post.get("workToProve", 0))
post["priority"] = from_decimal(post["priority"])
if not is_list_like(post.get("topics")):
post["topics"] = [post["topics"]] if post.get("topics") else []
post["topics"] = [topic if is_0x_prefixed(topic) else encode_hex(topic)
for topic in post["topics"]]
return post
def test_send_transaction_to_contract_with_array_address_arguments(
runner, compiled_contracts_path, test_contract_address,
test_contract_name):
argument = f"{test_contract_address},{test_contract_address}"
result = runner.invoke(
main,
(f"transact --compiled-contracts {compiled_contracts_path} "
f"--jsonrpc test --gas-price 1 --contract-address {test_contract_address} "
f"-- {test_contract_name} functionWithArrayArgument {argument}"),
)
assert result.exit_code == 0
transaction_hash = result.output.splitlines()[-1]
assert is_hex(transaction_hash)
assert is_0x_prefixed(transaction_hash)
def _deserialize(self, value, attr, data):
if not is_0x_prefixed(value):
self.fail('missing_prefix')
if not is_checksum_address(value):
self.fail('invalid_checksum')
try:
value = to_canonical_address(value)
except ValueError:
self.fail('invalid_data')
if len(value) != 20:
self.fail('invalid_size')
return value
def _deserialize(self, value, attr, data):
if not is_0x_prefixed(value):
self.fail('missing_prefix')
if not is_checksum_address(value):
self.fail('invalid_checksum')
try:
value = to_canonical_address(value)
except ValueError:
self.fail('invalid_data')
if len(value) != 20:
self.fail('invalid_size')
return value
def test_send_transaction_to_contract_from_compiled_contracts(
runner, test_contract_address, test_contract_name, compiled_contracts_path
):
result = runner.invoke(
main,
(
f"transact --compiled-contracts {compiled_contracts_path} "
f"--jsonrpc test --contract-address {test_contract_address} "
f"-- {test_contract_name} set 1"
),
)
assert result.exit_code == 0
transaction_hash = result.output.splitlines()[-1]
assert is_hex(transaction_hash)
assert is_0x_prefixed(transaction_hash)
def eth_call(to, sig, data="0x"):
if not is_0x_prefixed(sig):
sig = to_hex(function_signature_to_4byte_selector(sig))
if isinstance(data, bytes):
data = to_hex(data)
return requests.post(
BASE_URL,
json={
"jsonrpc": "2.0",
"method": "eth_call",
"params": [{
"to": to,
"data": sig + data[2:]
}, "latest"],
"id": 12,
},
).json()["result"]
def data_decoder(data: str) -> bytes:
assert is_0x_prefixed(data)
data = decode_hex(data)
return data
