def _decode_keyfile_json_v3(keyfile_json, password):
crypto = keyfile_json['crypto']
kdf = crypto['kdf']
# Derive the encryption key from the password using the key derivation
# function.
if kdf == 'pbkdf2':
derived_key = _derive_pbkdf_key(crypto, password)
elif kdf == 'scrypt':
derived_key = _derive_scrypt_key(crypto, password)
else:
raise TypeError("Unsupported key derivation function: {0}".format(kdf))
# Validate that the derived key matchs the provided MAC
ciphertext = decode_hex(crypto['ciphertext'])
mac = keccak(derived_key[16:32] + ciphertext)
expected_mac = decode_hex(crypto['mac'])
if not hmac.compare_digest(mac, expected_mac):
raise ValueError("MAC mismatch")
# Decrypt the ciphertext using the derived encryption key to get the
# private key.
encrypt_key = derived_key[:16]
cipherparams = crypto['cipherparams']
iv = big_endian_to_int(decode_hex(cipherparams['iv']))
private_key = decrypt_aes_ctr(ciphertext, encrypt_key, iv)
return private_key
def test_class_construction_sets_class_vars(web3, MATH_ABI, MATH_CODE,
MATH_RUNTIME):
MathContract = web3.eth.contract(
abi=MATH_ABI,
bytecode=MATH_CODE,
bytecode_runtime=MATH_RUNTIME,
)
assert MathContract.web3 == web3
assert MathContract.bytecode == decode_hex(MATH_CODE)
assert MathContract.bytecode_runtime == decode_hex(MATH_RUNTIME)
def test_class_construction_sets_class_vars(
web3,
MATH_ABI,
MATH_CODE,
MATH_RUNTIME,
some_address,
):
MathContract = web3.eth.contract(
abi=MATH_ABI,
bytecode=MATH_CODE,
bytecode_runtime=MATH_RUNTIME,
)
classic = MathContract(some_address)
assert classic.web3 == web3
assert classic.bytecode == decode_hex(MATH_CODE)
assert classic.bytecode_runtime == decode_hex(MATH_RUNTIME)
def _derive_pbkdf_key(crypto, password):
kdf_params = crypto['kdfparams']
salt = decode_hex(kdf_params['salt'])
dklen = kdf_params['dklen']
should_be_hmac, _, hash_name = kdf_params['prf'].partition('-')
assert should_be_hmac == 'hmac'
iterations = kdf_params['c']
derive_pbkdf_key = _pbkdf2_hash(password, hash_name, salt, iterations, dklen)
return derive_pbkdf_key
def test_contract_deployment_no_constructor(web3, MathContract, MATH_RUNTIME):
deploy_txn = MathContract.constructor().transact()
txn_receipt = web3.eth.waitForTransactionReceipt(deploy_txn)
assert txn_receipt is not None
assert txn_receipt['contractAddress']
contract_address = txn_receipt['contractAddress']
blockchain_code = web3.eth.getCode(contract_address)
assert blockchain_code == decode_hex(MATH_RUNTIME)
def test_contract_deployment_with_constructor_without_args(
web3, SimpleConstructorContract, SIMPLE_CONSTRUCTOR_RUNTIME):
deploy_txn = SimpleConstructorContract.constructor().transact()
txn_receipt = web3.eth.waitForTransactionReceipt(deploy_txn)
assert txn_receipt is not None
assert txn_receipt['contractAddress']
contract_address = txn_receipt['contractAddress']
blockchain_code = web3.eth.getCode(contract_address)
assert blockchain_code == decode_hex(SIMPLE_CONSTRUCTOR_RUNTIME)
def test_miner_setExtra(web3_empty, wait_for_block):
web3 = web3_empty
initial_extra = decode_hex(web3.eth.getBlock(web3.eth.blockNumber)['extraData'])
new_extra_data = b'-this-is-32-bytes-of-extra-data-'
# sanity
assert initial_extra != new_extra_data
web3.miner.setExtra(new_extra_data)
with Timeout(60) as timeout:
while True:
extra_data = decode_hex(web3.eth.getBlock(web3.eth.blockNumber)['extraData'])
if extra_data == new_extra_data:
break
timeout.sleep(random.random())
after_extra = decode_hex(web3.eth.getBlock(web3.eth.blockNumber)['extraData'])
assert after_extra == new_extra_data
def test_contract_constructor_transact_with_constructor_with_address_arguments(
web3, WithConstructorAddressArgumentsContract,
WITH_CONSTRUCTOR_ADDRESS_RUNTIME, address_conversion_func):
deploy_txn = WithConstructorAddressArgumentsContract.constructor(
TEST_ADDRESS).transact()
txn_receipt = web3.eth.waitForTransactionReceipt(deploy_txn)
assert txn_receipt is not None
assert txn_receipt['contractAddress']
contract_address = address_conversion_func(txn_receipt['contractAddress'])
blockchain_code = web3.eth.getCode(contract_address)
assert blockchain_code == decode_hex(WITH_CONSTRUCTOR_ADDRESS_RUNTIME)
assert TEST_ADDRESS == WithConstructorAddressArgumentsContract(
address=contract_address).functions.testAddr().call()
def test_contract_deployment_with_constructor_with_arguments(
web3, WithConstructorArgumentsContract,
WITH_CONSTRUCTOR_ARGUMENTS_RUNTIME):
deploy_txn = WithConstructorArgumentsContract.constructor(
1234, 'abcd').transact()
txn_receipt = web3.eth.waitForTransactionReceipt(deploy_txn)
assert txn_receipt is not None
assert txn_receipt['contractAddress']
contract_address = txn_receipt['contractAddress']
blockchain_code = web3.eth.getCode(contract_address)
assert blockchain_code == decode_hex(WITH_CONSTRUCTOR_ARGUMENTS_RUNTIME)
def test_contract_deployment_with_constructor_with_address_argument(
web3,
WithConstructorAddressArgumentsContract, # noqa: E501
WITH_CONSTRUCTOR_ADDRESS_RUNTIME): # noqa: E501
deploy_txn = WithConstructorAddressArgumentsContract.constructor(
"0x16D9983245De15E7A9A73bC586E01FF6E08dE737", ).transact()
txn_receipt = web3.eth.waitForTransactionReceipt(deploy_txn)
assert txn_receipt is not None
assert txn_receipt['contractAddress']
contract_address = txn_receipt['contractAddress']
blockchain_code = web3.eth.getCode(contract_address)
assert blockchain_code == decode_hex(WITH_CONSTRUCTOR_ADDRESS_RUNTIME)
def _derive_scrypt_key(crypto, password):
kdf_params = crypto['kdfparams']
salt = decode_hex(kdf_params['salt'])
p = kdf_params['p']
r = kdf_params['r']
n = kdf_params['n']
buflen = kdf_params['dklen']
derived_scrypt_key = _scrypt_hash(
password,
salt=salt,
n=n,
r=r,
p=p,
buflen=buflen,
)
return derived_scrypt_key
def to_bytes(primitive=None, hexstr=None, text=None):
assert_one_val(primitive, hexstr=hexstr, text=text)
if is_boolean(primitive):
return b'\x01' if primitive else b'\x00'
elif isinstance(primitive, bytes):
return primitive
elif is_integer(primitive):
return to_bytes(hexstr=to_hex(primitive))
elif hexstr is not None:
if len(hexstr) % 2:
hexstr = '0x0' + remove_0x_prefix(hexstr)
return decode_hex(hexstr)
elif text is not None:
return text.encode('utf-8')
raise TypeError(
"expected an int in first arg, or keyword of hexstr or text")
def test_contract_constructor_transact_with_constructor_with_arguments(
web3, WithConstructorArgumentsContract,
WITH_CONSTRUCTOR_ARGUMENTS_RUNTIME, constructor_args,
constructor_kwargs, expected_a, expected_b, address_conversion_func):
deploy_txn = WithConstructorArgumentsContract.constructor(
*constructor_args, **constructor_kwargs).transact()
txn_receipt = web3.eth.waitForTransactionReceipt(deploy_txn)
assert txn_receipt is not None
assert txn_receipt['contractAddress']
contract_address = address_conversion_func(txn_receipt['contractAddress'])
blockchain_code = web3.eth.getCode(contract_address)
assert blockchain_code == decode_hex(WITH_CONSTRUCTOR_ARGUMENTS_RUNTIME)
assert expected_a == WithConstructorArgumentsContract(
address=contract_address).functions.data_a().call()
assert expected_b == WithConstructorArgumentsContract(
address=contract_address).functions.data_b().call()
