def _encode_abi(cls, abi, arguments, data=None):
argument_types = get_abi_input_types(abi)
if not check_if_arguments_can_be_encoded(abi, arguments, {}):
raise TypeError(
"One or more arguments could not be encoded to the necessary "
"ABI type. Expected types are: {0}".format(
', '.join(argument_types),
)
)
try:
encoded_arguments = encode_abi(
argument_types,
force_obj_to_bytes(arguments),
)
except EncodingError as e:
raise TypeError(
"One or more arguments could not be encoded to the necessary "
"ABI type: {0}".format(str(e))
)
if data:
return add_0x_prefix(
force_bytes(remove_0x_prefix(data)) +
force_bytes(remove_0x_prefix(encode_hex(encoded_arguments)))
)
else:
return encode_hex(encoded_arguments)
def _encode_abi(cls, abi, arguments, data=None):
argument_types = get_abi_input_types(abi)
if not check_if_arguments_can_be_encoded(abi, arguments, {}):
raise TypeError(
"One or more arguments could not be encoded to the necessary "
"ABI type. Expected types are: {0}".format(
', '.join(argument_types), ))
try:
encoded_arguments = encode_abi(
argument_types,
force_obj_to_bytes(arguments),
)
except EncodingError as e:
raise TypeError(
"One or more arguments could not be encoded to the necessary "
"ABI type: {0}".format(str(e)))
if data:
return add_0x_prefix(
force_bytes(remove_0x_prefix(data)) +
force_bytes(remove_0x_prefix(encode_hex(encoded_arguments))))
else:
return encode_hex(encoded_arguments)
def _encodeABI(cls, abi, arguments, data=None):
arguent_types = get_abi_input_types(abi)
encoded_arguments = encode_abi(arguent_types,
force_obj_to_bytes(arguments))
if data:
return add_0x_prefix(
force_bytes(remove_0x_prefix(data)) +
force_bytes(remove_0x_prefix(encode_hex(encoded_arguments))))
else:
return encode_hex(encoded_arguments)
def _encodeABI(cls, abi, arguments, data=None):
arguent_types = get_abi_input_types(abi)
encoded_arguments = encode_abi(arguent_types, force_obj_to_bytes(arguments))
if data:
return add_0x_prefix(
force_bytes(remove_0x_prefix(data)) +
force_bytes(remove_0x_prefix(encode_hex(encoded_arguments)))
)
else:
return encode_hex(encoded_arguments)
def request_blocking(self, method, params):
if method == 'eth_sendTransaction':
base_transaction = params[0]
# create a fully signed transaction and send through the
# `eth_sendRawTransaction` endpoint instead.
full_transaction = self.construct_full_transaction(base_transaction)
raw_transaction_bytes = self.sign_and_serialize_transaction(
full_transaction,
)
raw_transaction_bytes_as_hex = encode_hex(raw_transaction_bytes)
return self.request_blocking(
'eth_sendRawTransaction', [raw_transaction_bytes_as_hex],
)
result = super(BaseSendRawTransactionMixin, self).request_blocking(
method, params,
)
if method in self.TXN_SENDING_METHODS:
if method == 'eth_sendRawTransaction':
txn = rlp.decode(decode_hex(params[0]), Transaction)
self._known_transactions[to_address(txn.sender)].add(result)
self._known_nonces[to_address(txn.sender)].add(txn.nonce)
else:
txn = params[0]
self._known_transactions[to_address(txn['from'])].add(result)
if 'nonce' in txn:
self._known_nonces[to_address(txn['from'])].add(
to_decimal(txn['nonce'])
)
return result
def test_adding_signature_to_transaction(wait_for_first_block, web3,
skip_if_testrpc):
skip_if_testrpc(web3)
transaction = {
'nonce': hex(0),
'to': '0xd3cda913deb6f67967b99d67acdfa1712c293601',
'value': hex(12345),
'gas': hex(1200300),
'gasPrice': hex(54321),
'data': '0x1234567890abcdef',
}
serialized_txn = serialize_transaction(transaction)
signature_hex = web3.eth.sign(web3.eth.coinbase, serialized_txn)
signed_transaction = add_signature_to_transaction(
serialized_txn,
decode_hex(signature_hex),
)
assert to_address(signed_transaction.to) == transaction['to']
assert signed_transaction.startgas == int(transaction['gas'], 16)
assert signed_transaction.gasprice == int(transaction['gasPrice'], 16)
assert signed_transaction.nonce == int(transaction['nonce'], 16)
assert signed_transaction.value == int(transaction['value'], 16)
assert encode_hex(signed_transaction.data) == transaction['data']
assert signed_transaction.sender == web3.eth.coinbase
def test_migrations_store_receipts_on_completion(web3, MATH, chain):
registrar = chain.registrar
class MockOperation(Operation):
def execute(self, *args, **kwargs):
return {
'raw-address':
web3.eth.coinbase,
'raw-txn':
'0xebb0f76aa6a6bb8d178ac2354de83d73a728d704bf47d135c188ca7b6d25f2e4',
'no-key':
Address.defer(value=web3.eth.coinbase),
'with-key':
String.defer(key='this-is-a-key', value='this-is-a-string'),
}
class TestMigration(Migration):
migration_id = '0001_initial'
dependencies = []
operations = [
MockOperation(),
]
assert registrar.call().exists('migration/0001_initial') is False
assert registrar.call().exists(
'migration/0001_initial/operation/0') is False
assert registrar.call().exists(
'migration/0001_initial/operation/0/raw-address') is False
assert registrar.call().exists(
'migration/0001_initial/operation/0/raw-txn') is False
assert registrar.call().exists(
'migration/0001_initial/operation/0/no-key') is False
assert registrar.call().exists('this-is-a-key') is False
migration = TestMigration(chain)
migration.execute()
assert registrar.call().exists('migration/0001_initial') is True
assert registrar.call().exists(
'migration/0001_initial/operation/0') is True
assert registrar.call().exists(
'migration/0001_initial/operation/0/raw-address') is True
assert registrar.call().exists(
'migration/0001_initial/operation/0/raw-txn') is True
assert registrar.call().exists(
'migration/0001_initial/operation/0/no-key') is True
assert registrar.call().exists('this-is-a-key') is True
assert registrar.call().getBool('migration/0001_initial') is True
assert registrar.call().getBool(
'migration/0001_initial/operation/0') is True
assert registrar.call().getAddress(
'migration/0001_initial/operation/0/raw-address') == web3.eth.coinbase
assert encode_hex(
registrar.call().get('migration/0001_initial/operation/0/raw-txn')
) == '0xebb0f76aa6a6bb8d178ac2354de83d73a728d704bf47d135c188ca7b6d25f2e4'
assert registrar.call().getAddress(
'migration/0001_initial/operation/0/no-key') == web3.eth.coinbase
assert registrar.call().getString('this-is-a-key') == 'this-is-a-string'
def sign(self, account, data):
data_hash = self.web3._requestManager.request_blocking(
"web3_sha3", [encode_hex(data)],
)
return self.web3._requestManager.request_blocking(
"eth_sign", [account, data_hash],
)
def test_adding_signature_to_transaction(wait_for_first_block,
web3,
skip_if_testrpc):
skip_if_testrpc(web3)
transaction = {
'nonce': hex(0),
'to': '0xd3cda913deb6f67967b99d67acdfa1712c293601',
'value': hex(12345),
'gas': hex(1200300),
'gasPrice': hex(54321),
'data': '0x1234567890abcdef',
}
serialized_txn = serialize_transaction(transaction)
signature_hex = web3.eth.sign(web3.eth.coinbase, serialized_txn)
signed_transaction = add_signature_to_transaction(
serialized_txn,
decode_hex(signature_hex),
)
assert to_address(signed_transaction.to) == transaction['to']
assert signed_transaction.startgas == int(transaction['gas'], 16)
assert signed_transaction.gasprice == int(transaction['gasPrice'], 16)
assert signed_transaction.nonce == int(transaction['nonce'], 16)
assert signed_transaction.value == int(transaction['value'], 16)
assert encode_hex(signed_transaction.data) == transaction['data']
assert signed_transaction.sender == web3.eth.coinbase
def request_blocking(self, method, params):
if method == 'eth_sendTransaction':
base_transaction = params[0]
# create a fully signed transaction and send through the
# `eth_sendRawTransaction` endpoint instead.
full_transaction = self.construct_full_transaction(base_transaction)
raw_transaction_bytes = self.sign_and_serialize_transaction(
full_transaction,
)
raw_transaction_bytes_as_hex = encode_hex(raw_transaction_bytes)
return self.request_blocking(
'eth_sendRawTransaction', [raw_transaction_bytes_as_hex],
)
result = super(BaseSendRawTransactionMixin, self).request_blocking(
method, params,
)
if method in self.TXN_SENDING_METHODS:
if method == 'eth_sendRawTransaction':
txn = rlp.decode(decode_hex(params[0]), Transaction)
self._known_transactions[to_address(txn.sender)].add(result)
self._known_nonces[to_address(txn.sender)].add(txn.nonce)
else:
txn = params[0]
self._known_transactions[to_address(txn['from'])].add(result)
if 'nonce' in txn:
self._known_nonces[to_address(txn['from'])].add(
to_decimal(txn['nonce'])
)
return result
def test_contract_constructor_encoding_encoding(
WithConstructorArgumentsContract):
deploy_data = WithConstructorArgumentsContract._encode_constructor_data(
[1234, 'abcd'])
encoded_args = '0x00000000000000000000000000000000000000000000000000000000000004d26162636400000000000000000000000000000000000000000000000000000000'
expected_ending = encode_hex(
encode_abi(['uint256', 'bytes32'], [1234, b'abcd']))
assert expected_ending == encoded_args
assert deploy_data.endswith(remove_0x_prefix(expected_ending))
def sign(self, account, data):
data_hash = self.web3._requestManager.request_blocking(
"web3_sha3",
[encode_hex(data)],
)
return self.web3._requestManager.request_blocking(
"eth_sign",
[account, data_hash],
)
def test_special_case_for_txn_hash():
txn_hash = '0xebb0f76aa6a6bb8d178ac2b54de2fd7ca738d704bf47d135c188ca7b6d35f2e4'
value_setters = generate_registrar_value_setters(txn_hash)
assert len(value_setters) == 1
setter = value_setters[0]
assert issubclass(setter, RegistrarValue)
assert encode_hex(setter.value) == txn_hash
assert setter.value_type == 'bytes32'
def unknown_token_id(token_v1, web3):
token = token_v1
unknown_token_id = decode_hex(web3.sha3(encode_hex('Hudson James')))
assert unknown_token_id == sha3_256(b'Hudson James').digest()
assert token.call().identityOf(unknown_token_id) == ''
assert token.call().ownerOf(
unknown_token_id) == '0x0000000000000000000000000000000000000000'
return unknown_token_id
def test_special_case_for_txn_hash():
txn_hash = '0xebb0f76aa6a6bb8d178ac2b54de2fd7ca738d704bf47d135c188ca7b6d35f2e4'
value_setters = generate_registrar_value_setters(txn_hash)
assert len(value_setters) == 1
setter = value_setters[0]
assert issubclass(setter, RegistrarValue)
assert encode_hex(setter.value) == txn_hash
assert setter.value_type == 'bytes32'
def importRawKey(self, private_key, passphrase):
if len(private_key) == 66:
private_key = remove_0x_prefix(private_key)
elif len(private_key) == 32:
private_key = remove_0x_prefix(encode_hex(private_key))
elif len(private_key) == 64:
pass
else:
raise ValueError("Unknown private key format")
return self.request_manager.request_blocking(
"personal_importRawKey",
[private_key, passphrase],
)
def importRawKey(self, private_key, passphrase):
if len(private_key) == 66:
private_key = remove_0x_prefix(private_key)
elif len(private_key) == 32:
private_key = remove_0x_prefix(encode_hex(private_key))
elif len(private_key) == 64:
pass
else:
raise ValueError("Unknown private key format")
return self.request_manager.request_blocking(
"personal_importRawKey",
[private_key, passphrase],
)
def get_transaction_signature(self, transaction):
serialized_txn = serialize_transaction(transaction)
hash_to_sign = self.signing_manager.request_blocking(
'web3_sha3', [encode_hex(serialized_txn)],
)
signature_hex = self.signing_manager.request_blocking(
'eth_sign',
[
transaction['from'],
hash_to_sign,
],
)
signature = decode_hex(signature_hex)
return signature
def get_transaction_signature(self, transaction):
serialized_txn = serialize_transaction(transaction)
hash_to_sign = self.signing_manager.request_blocking(
'web3_sha3', [encode_hex(serialized_txn)],
)
signature_hex = self.signing_manager.request_blocking(
'eth_sign',
[
transaction['from'],
hash_to_sign,
],
)
signature = decode_hex(signature_hex)
return signature
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_array(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_migrations_store_receipts_on_completion(web3, MATH, chain):
registrar = chain.registrar
class MockOperation(Operation):
def execute(self, *args, **kwargs):
return {
'raw-address': web3.eth.coinbase,
'raw-txn': '0xebb0f76aa6a6bb8d178ac2354de83d73a728d704bf47d135c188ca7b6d25f2e4',
'no-key': Address.defer(value=web3.eth.coinbase),
'with-key': String.defer(key='this-is-a-key', value='this-is-a-string'),
}
class TestMigration(Migration):
migration_id = '0001_initial'
dependencies = []
operations = [
MockOperation(),
]
assert registrar.call().exists('migration/0001_initial') is False
assert registrar.call().exists('migration/0001_initial/operation/0') is False
assert registrar.call().exists('migration/0001_initial/operation/0/raw-address') is False
assert registrar.call().exists('migration/0001_initial/operation/0/raw-txn') is False
assert registrar.call().exists('migration/0001_initial/operation/0/no-key') is False
assert registrar.call().exists('this-is-a-key') is False
migration = TestMigration(chain)
migration.execute()
assert registrar.call().exists('migration/0001_initial') is True
assert registrar.call().exists('migration/0001_initial/operation/0') is True
assert registrar.call().exists('migration/0001_initial/operation/0/raw-address') is True
assert registrar.call().exists('migration/0001_initial/operation/0/raw-txn') is True
assert registrar.call().exists('migration/0001_initial/operation/0/no-key') is True
assert registrar.call().exists('this-is-a-key') is True
assert registrar.call().getBool('migration/0001_initial') is True
assert registrar.call().getBool('migration/0001_initial/operation/0') is True
assert registrar.call().getAddress('migration/0001_initial/operation/0/raw-address') == web3.eth.coinbase
assert encode_hex(registrar.call().get('migration/0001_initial/operation/0/raw-txn')) == '0xebb0f76aa6a6bb8d178ac2354de83d73a728d704bf47d135c188ca7b6d25f2e4'
assert registrar.call().getAddress('migration/0001_initial/operation/0/no-key') == web3.eth.coinbase
assert registrar.call().getString('this-is-a-key') == 'this-is-a-string'
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_array(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_transaction_serialization():
transaction = {
'nonce': hex(0),
'to': '0xd3cda913deb6f67967b99d67acdfa1712c293601',
'value': hex(12345),
'gas': hex(1200300),
'gasPrice': hex(54321),
'data': '0x1234567890abcdef',
}
serialized_txn = serialize_transaction(transaction)
unserialized_txn = rlp.decode(serialized_txn, UnsignedTransaction)
assert to_address(unserialized_txn.to) == transaction['to']
assert unserialized_txn.startgas == int(transaction['gas'], 16)
assert unserialized_txn.gasprice == int(transaction['gasPrice'], 16)
assert unserialized_txn.nonce == int(transaction['nonce'], 16)
assert unserialized_txn.value == int(transaction['value'], 16)
assert encode_hex(unserialized_txn.data) == transaction['data']
def test_transaction_serialization():
transaction = {
'nonce': hex(0),
'to': '0xd3cda913deb6f67967b99d67acdfa1712c293601',
'value': hex(12345),
'gas': hex(1200300),
'gasPrice': hex(54321),
'data': '0x1234567890abcdef',
}
serialized_txn = serialize_transaction(transaction)
unserialized_txn = rlp.decode(serialized_txn, UnsignedTransaction)
assert to_address(unserialized_txn.to) == transaction['to']
assert unserialized_txn.startgas == int(transaction['gas'], 16)
assert unserialized_txn.gasprice == int(transaction['gasPrice'], 16)
assert unserialized_txn.nonce == int(transaction['nonce'], 16)
assert unserialized_txn.value == int(transaction['value'], 16)
assert encode_hex(unserialized_txn.data) == transaction['data']
def _inner_sign(account, data_to_sign):
signature_hash_hex = web3.sha3(encode_hex(data_to_sign))
signature_hash_bytes = decode_hex(signature_hash_hex)
private_key = tester.keys[tester.accounts.index(decode_hex(account))]
priv_key = PrivateKey(flags=ALL_FLAGS)
priv_key.set_raw_privkey(private_key)
signature_raw = priv_key.ecdsa_sign_recoverable(
signature_hash_bytes,
raw=True,
digest=sha3_256,
)
signature_bytes, rec_id = priv_key.ecdsa_recoverable_serialize(signature_raw)
signature = signature_bytes + force_bytes(chr(rec_id))
# Sanity check that the signature is valid.
signer_address = force_text(extract_ecdsa_signer(
signature_hash_bytes,
signature,
))
assert signer_address == account
return signature
def sha3(self, value, encoding="hex"):
if encoding == 'hex':
hex_string = value
else:
hex_string = encode_hex(value)
return self._requestManager.request_blocking('web3_sha3', [hex_string])
def sha3(self, value, encoding="hex"):
if encoding == 'hex':
hex_string = value
else:
hex_string = encode_hex(value)
return self._requestManager.request_blocking('web3_sha3', [hex_string])
def test_hex_encode_decode_round_trip(value):
intermediate_value = encode_hex(value)
result_value = decode_hex(intermediate_value)
assert result_value == value, "Expected: {0!r}, Result: {1!r}, Intermediate: {2!r}".format(
value, result_value, intermediate_value)
def test_eth_sign(web3_empty, skip_if_testrpc):
web3 = web3_empty
skip_if_testrpc(web3)
private_key_hex = '0x5e95384d8050109aab08c1922d3c230739bc16976553c317e5d0b87b59371f2a'
private_key = decode_hex(private_key_hex)
# This imports the private key into the running geth instance and unlocks
# the account so that it can sign things.
# `0xa5df35f30ba0ce878b1061ae086289adff3ba1e0`
address = web3.personal.importRawKey(private_key, "password")
web3.personal.unlockAccount(address, "password")
assert add_0x_prefix(encode_hex(
privtoaddr(private_key))) == add_0x_prefix(address)
assert address == '0xa5df35f30ba0ce878b1061ae086289adff3ba1e0'
# the data to be signed
data = b'1234567890abcdefghijklmnopqrstuvwxyz'
# the hash of the data `0x089c33d56ed10bd8b571a0f493cedb28db1ae0f40c6cd266243001528c06eab3`
data_hash = web3.sha3(data, encoding=None)
data_hash_bytes = decode_hex(data_hash)
assert force_bytes(data_hash) == sha3(data)
priv_key = PrivateKey(flags=ALL_FLAGS)
priv_key.set_raw_privkey(private_key)
# sanit check the extract_ecdsa_signer function works as expected.
vector_sig = priv_key.ecdsa_sign_recoverable(data_hash_bytes,
raw=True,
digest=sha3_256)
vector_sig_bytes, rec_id = priv_key.ecdsa_recoverable_serialize(vector_sig)
vector_sig_bytes_full = vector_sig_bytes + force_bytes(chr(rec_id))
vector_address = force_text(
extract_ecdsa_signer(data_hash_bytes, vector_sig_bytes_full))
assert vector_address == address
# Now have geth sign some data.
signature_hex = web3.eth.sign(address, data)
signature_bytes = decode_hex(signature_hex)
actual_signer = extract_ecdsa_signer(data_hash_bytes, signature_bytes)
assert actual_signer == address
# Verify the signature against the public key derived from the
# original private key. It fails.
rec_id = signature_bytes[64]
if is_string(rec_id):
rec_id = ord(rec_id)
recoverable_signature = priv_key.ecdsa_recoverable_deserialize(
signature_bytes[:64],
rec_id,
)
signature = priv_key.ecdsa_recoverable_convert(recoverable_signature)
is_valid = priv_key.pubkey.ecdsa_verify(
msg=data,
raw_sig=signature,
digest=sha3_256,
)
assert is_valid
def test_encode_hex(value, expected):
assert encode_hex(value) == expected
def test_contract_constructor_encoding_encoding(WithConstructorArgumentsContract):
deploy_data = WithConstructorArgumentsContract.encodeConstructorData([1234, 'abcd'])
encoded_args = b'0x00000000000000000000000000000000000000000000000000000000000004d26162636400000000000000000000000000000000000000000000000000000000'
expected_ending = encode_hex(encode_abi(['uint256', 'bytes32'], [1234, b'abcd']))
assert expected_ending == encoded_args
assert deploy_data.endswith(remove_0x_prefix(expected_ending))
def test_eth_sign(web3_empty, skip_if_testrpc):
web3 = web3_empty
skip_if_testrpc(web3)
private_key_hex = '0x5e95384d8050109aab08c1922d3c230739bc16976553c317e5d0b87b59371f2a'
private_key = decode_hex(private_key_hex)
# This imports the private key into the running geth instance and unlocks
# the account so that it can sign things.
# `0xa5df35f30ba0ce878b1061ae086289adff3ba1e0`
address = web3.personal.importRawKey(private_key, "password")
web3.personal.unlockAccount(address, "password")
assert add_0x_prefix(encode_hex(privtoaddr(private_key))) == add_0x_prefix(address)
assert address == '0xa5df35f30ba0ce878b1061ae086289adff3ba1e0'
# the data to be signed
data = b'1234567890abcdefghijklmnopqrstuvwxyz'
# the hash of the data `0x089c33d56ed10bd8b571a0f493cedb28db1ae0f40c6cd266243001528c06eab3`
data_hash = web3.sha3(data, encoding=None)
data_hash_bytes = decode_hex(data_hash)
assert force_bytes(data_hash) == sha3(data)
priv_key = PrivateKey(flags=ALL_FLAGS)
priv_key.set_raw_privkey(private_key)
# sanit check the extract_ecdsa_signer function works as expected.
vector_sig = priv_key.ecdsa_sign_recoverable(data_hash_bytes, raw=True, digest=sha3_256)
vector_sig_bytes, rec_id = priv_key.ecdsa_recoverable_serialize(vector_sig)
vector_sig_bytes_full = vector_sig_bytes + force_bytes(chr(rec_id))
vector_address = force_text(extract_ecdsa_signer(data_hash_bytes, vector_sig_bytes_full))
assert vector_address == address
# Now have geth sign some data.
signature_hex = web3.eth.sign(address, data)
signature_bytes = decode_hex(signature_hex)
actual_signer = extract_ecdsa_signer(data_hash_bytes, signature_bytes)
assert actual_signer == address
# Verify the signature against the public key derived from the
# original private key. It fails.
rec_id = signature_bytes[64]
if is_string(rec_id):
rec_id = ord(rec_id)
recoverable_signature = priv_key.ecdsa_recoverable_deserialize(
signature_bytes[:64],
rec_id,
)
signature = priv_key.ecdsa_recoverable_convert(recoverable_signature)
is_valid = priv_key.pubkey.ecdsa_verify(
msg=data,
raw_sig=signature,
digest=sha3_256,
)
assert is_valid
def test_encode_hex(value, expected):
assert encode_hex(value) == expected
def test_hex_encode_decode_round_trip(value):
intermediate_value = encode_hex(value)
result_value = decode_hex(intermediate_value)
assert result_value == value, "Expected: {0!r}, Result: {1!r}, Intermediate: {2!r}".format(value, result_value, intermediate_value)
