class ENRFactory(factory.Factory): # type: ignore
class Meta:
model = ENR
sequence_number = factory.Faker("pyint", min_value=0, max_value=100)
kv_pairs = factory.LazyAttribute(
lambda o: merge(
{
b"id": b"v4",
b"secp256k1": keys.PrivateKey(
o.private_key
).public_key.to_compressed_bytes(),
b"ip": o.address.ip_packed,
b"udp": o.address.udp_port,
b"tcp": o.address.tcp_port,
},
o.custom_kv_pairs,
)
)
signature = factory.LazyAttribute(
lambda o: UnsignedENR(o.sequence_number, o.kv_pairs)
.to_signed_enr(o.private_key)
.signature
)
class Params:
private_key = factory.Faker("binary", length=V4IdentityScheme.private_key_size)
address = factory.SubFactory(AddressFactory)
custom_kv_pairs: Dict[bytes, Any] = {}
@classmethod
def minimal(cls) -> ENRAPI:
private_key = PrivateKeyFactory()
kv_pairs = {
b"id": b"v4",
b"secp256k1": private_key.public_key.to_compressed_bytes(),
}
return cls(private_key=private_key.to_bytes(), kv_pairs=kv_pairs)
def test_unsigned_to_eip155_signed_transaction(txn_fixture, transaction_class):
if txn_fixture['chainId'] is None:
pytest.skip('No chain id for EIP155 signing')
elif transaction_class in {FrontierTransaction, HomesteadTransaction}:
pytest.skip('Transaction class is not chain aware')
key = keys.PrivateKey(decode_hex(txn_fixture['key']))
unsigned_txn = transaction_class.create_unsigned_transaction(
nonce=txn_fixture['nonce'],
gas_price=txn_fixture['gasPrice'],
gas=txn_fixture['gas'],
to=(
to_canonical_address(txn_fixture['to'])
if txn_fixture['to']
else b''
),
value=txn_fixture['value'],
data=decode_hex(txn_fixture['data']),
)
signed_txn = unsigned_txn.as_signed_transaction(key, chain_id=txn_fixture['chainId'])
assert is_same_address(signed_txn.sender, key.public_key.to_canonical_address())
assert signed_txn.chain_id == txn_fixture['chainId']
def generate_tx_from_msg(self, msg):
# TODO: Perhaps this check should be in the client, and not the Shard class
# TODO 'msg.base_hash == self.chain.get_block_by_hash(msg.base_hash).header.hash' is a check hack in lack of py-evm documentation
assert msg.target_shard_id == self.shard_id, "Expected target_shard_id to be this shard"
assert msg.tx.to in self.accounts[
'addresses'], "Expected 'to' in this shard's accounts"
assert msg.base_hash == self.chain.get_block_by_hash(
msg.base_hash).header.hash, "Expected base in this shard"
magic_sender_pri_key = keys.PrivateKey(decode_hex(MAGIC_PRI_KEY))
magic_sender_address = Address(
magic_sender_pri_key.public_key.to_canonical_address())
nonce = self.vm.state.account_db.get_nonce(magic_sender_address)
tx = self.vm.create_unsigned_transaction(
nonce=nonce,
gas_price=msg.tx.gas_price,
gas=msg.tx.gas,
to=msg.tx.to,
value=msg.tx.value,
# TODO: data should reflect message info
data='msg_data'.encode('utf-8'),
)
tx = tx.as_signed_transaction(magic_sender_pri_key)
return tx
def sign_message_preparing_for_ec_recover(msg, priv_key):
privkey = PrivateKey(bytes(bytearray.fromhex(priv_key)), raw=True)
private_key = keys.PrivateKey(privkey.private_key)
address = private_key.public_key.to_checksum_address()
#log("address", address)
message_hash = my_eth_sign_sha3(msg)
#log(Web3.toHex(message_hash))
signed_message = web3.eth.account.signHash(message_hash,
private_key=private_key)
#log(signed_message)
ec_recover_args = (msghash, v, r,
s) = (Web3.toHex(signed_message.messageHash),
signed_message.v, to_32byte_hex(signed_message.r),
to_32byte_hex(signed_message.s))
return ec_recover_args
def create_account():
from eth_utils import (
keccak, )
from web3._utils.encoding import (
to_bytes, )
from eth_utils import (
to_hex, )
from eth_keys import (keys)
# acct = web3.account.Account.create('KEYSMASH FJAFJKLDSKF7JKFDJ 1530')
acct = account.Account.privateKeyToAccount(keccak(to_bytes(text="456")))
private_key = to_hex(acct.privateKey)
print("privateKey:", private_key)
pk = keys.PrivateKey(acct.privateKey)
public_key = "0x04" + pk.public_key.to_hex()[2:]
print("public_key:", pk.public_key.to_hex()[2:])
print("public_key:", public_key)
print(acct.address)
print("address:", acct.address)
import os
from eth_keys import keys
from eth_utils import decode_hex
INFURA_URL = os.environ['BN_CONSENSUS_INFURA_URL']
PRIVATE_KEY = os.environ['BN_CONSENSUS_PRIVATE_KEY']
ADDRESS = keys.PrivateKey(
decode_hex(PRIVATE_KEY)).public_key.to_checksum_address()
GAS = int(os.environ['BN_CONSENSUS_GAS'])
GAS_PRICE = int(os.environ['BN_CONSENSUS_GAS_PRICE'])
TO_ADDRESS = os.environ['BN_CONSENSUS_TO_ADDRESS']
SNAPSHOTS_PERIOD = int(os.environ['BN_CONSENSUS_SNAPSHOTS_PERIOD'])
SNAPSHOTS_PATH = "/snapshots/dump_{}.zip"
APPLY_URL = os.environ['BN_CONSENSUS_APPLY_URL']
DUMP_URL = os.environ['BN_CONSENSUS_DUMP_URL']
MAX_COLLECTION_SIZE = os.environ['BN_CONSENSUS_MAX_COLLECTION_SIZE']
VOTING_ABI = [{
'constant': True,
'inputs': [],
'name': 'hasInitialized',
'outputs': [{
'name': '',
'type': 'bool'
}],
'payable': False,
'stateMutability': 'view',
'type': 'function'
def random_private_key():
return keys.PrivateKey(random_hash())
def priv2addr(private_key):
pk = keys.PrivateKey(bytes.fromhex(private_key))
return pk.public_key.to_checksum_address()
def privatekey_to_publickey(private_key_bin: PrivateKey) -> PublicKey:
""" Returns public key in bitcoins 'bin' encoding. """
if not ishash(private_key_bin):
raise ValueError("private_key_bin format mismatch. maybe hex encoded?")
return keys.PrivateKey(private_key_bin).public_key.to_bytes()
async def test_handshake():
# TODO: this test should be re-written to not depend on functionality in the `ETHPeer` class.
cancel_token = CancelToken("test_handshake")
use_eip8 = False
initiator_remote = kademlia.Node(
keys.PrivateKey(test_values['receiver_private_key']).public_key,
kademlia.Address('0.0.0.0', 0, 0))
initiator = HandshakeInitiator(
initiator_remote,
keys.PrivateKey(test_values['initiator_private_key']), use_eip8,
cancel_token)
initiator.ephemeral_privkey = keys.PrivateKey(
test_values['initiator_ephemeral_private_key'])
responder_remote = kademlia.Node(
keys.PrivateKey(test_values['initiator_private_key']).public_key,
kademlia.Address('0.0.0.0', 0, 0))
responder = HandshakeResponder(
responder_remote, keys.PrivateKey(test_values['receiver_private_key']),
use_eip8, cancel_token)
responder.ephemeral_privkey = keys.PrivateKey(
test_values['receiver_ephemeral_private_key'])
# Check that the auth message generated by the initiator is what we expect. Notice that we
# can't use the auth_init generated here because the non-deterministic prefix would cause the
# derived secrets to not match the expected values.
_auth_init = initiator.create_auth_message(test_values['initiator_nonce'])
assert len(_auth_init) == len(test_values['auth_plaintext'])
assert _auth_init[65:] == test_values['auth_plaintext'][
65:] # starts with non deterministic k
# Check that encrypting and decrypting the auth_init gets us the orig msg.
_auth_init_ciphertext = initiator.encrypt_auth_message(_auth_init)
assert _auth_init == ecies.decrypt(_auth_init_ciphertext,
responder.privkey)
# Check that the responder correctly decodes the auth msg.
auth_msg_ciphertext = test_values['auth_ciphertext']
initiator_ephemeral_pubkey, initiator_nonce, _ = decode_authentication(
auth_msg_ciphertext, responder.privkey)
assert initiator_nonce == test_values['initiator_nonce']
assert initiator_ephemeral_pubkey == (keys.PrivateKey(
test_values['initiator_ephemeral_private_key']).public_key)
# Check that the auth_ack msg generated by the responder is what we expect.
auth_ack_msg = responder.create_auth_ack_message(
test_values['receiver_nonce'])
assert auth_ack_msg == test_values['authresp_plaintext']
# Check that the secrets derived from ephemeral key agreements match the expected values.
auth_ack_ciphertext = test_values['authresp_ciphertext']
aes_secret, mac_secret, egress_mac, ingress_mac = responder.derive_secrets(
initiator_nonce, test_values['receiver_nonce'],
initiator_ephemeral_pubkey, auth_msg_ciphertext, auth_ack_ciphertext)
assert aes_secret == test_values['aes_secret']
assert mac_secret == test_values['mac_secret']
# Test values are from initiator perspective, so they're reversed here.
assert ingress_mac.digest() == test_values['initial_egress_MAC']
assert egress_mac.digest() == test_values['initial_ingress_MAC']
# Check that the initiator secrets match as well.
responder_ephemeral_pubkey, responder_nonce = initiator.decode_auth_ack_message(
test_values['authresp_ciphertext'])
(initiator_aes_secret, initiator_mac_secret, initiator_egress_mac,
initiator_ingress_mac) = initiator.derive_secrets(
initiator_nonce, responder_nonce, responder_ephemeral_pubkey,
auth_msg_ciphertext, auth_ack_ciphertext)
assert initiator_aes_secret == aes_secret
assert initiator_mac_secret == mac_secret
assert initiator_ingress_mac.digest() == test_values['initial_ingress_MAC']
assert initiator_egress_mac.digest() == test_values['initial_egress_MAC']
# Finally, check that two Peers configured with the secrets generated above understand each
# other.
responder_reader = asyncio.StreamReader()
initiator_reader = asyncio.StreamReader()
# Link the initiator's writer to the responder's reader, and the responder's writer to the
# initiator's reader.
responder_writer = MockStreamWriter(initiator_reader.feed_data)
initiator_writer = MockStreamWriter(responder_reader.feed_data)
initiator_peer = DumbPeer(remote=initiator.remote,
privkey=initiator.privkey,
reader=initiator_reader,
writer=initiator_writer,
aes_secret=initiator_aes_secret,
mac_secret=initiator_mac_secret,
egress_mac=initiator_egress_mac,
ingress_mac=initiator_ingress_mac,
headerdb=None,
network_id=1)
initiator_peer.base_protocol.send_handshake()
responder_peer = DumbPeer(remote=responder.remote,
privkey=responder.privkey,
reader=responder_reader,
writer=responder_writer,
aes_secret=aes_secret,
mac_secret=mac_secret,
egress_mac=egress_mac,
ingress_mac=ingress_mac,
headerdb=None,
network_id=1)
responder_peer.base_protocol.send_handshake()
# The handshake msgs sent by each peer (above) are going to be fed directly into their remote's
# reader, and thus the read_msg() calls will return immediately.
responder_hello, _ = await responder_peer.read_msg()
initiator_hello, _ = await initiator_peer.read_msg()
assert isinstance(responder_hello, Hello)
assert isinstance(initiator_hello, Hello)
def get_nodes_to_connect(self):
nodekey = keys.PrivateKey(decode_hex(
"45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8"))
remoteid = nodekey.public_key.to_hex()
yield kademlia.Node(keys.PublicKey(decode_hex(remoteid)),
kademlia.Address('127.0.0.1', 30303, 30303))
def generate_random_keypair() -> Tuple[bytes, Address]:
key_object = keys.PrivateKey(
pad32(int_to_big_endian(random.getrandbits(8 * 32))))
return key_object.to_bytes(), Address(
key_object.public_key.to_canonical_address())
def test_state_fixtures(fixture, fixture_vm_class):
header = BlockHeader(
coinbase=fixture['env']['currentCoinbase'],
difficulty=fixture['env']['currentDifficulty'],
block_number=fixture['env']['currentNumber'],
gas_limit=fixture['env']['currentGasLimit'],
timestamp=fixture['env']['currentTimestamp'],
parent_hash=fixture['env']['previousHash'],
)
chaindb = ChainDB(get_db_backend())
vm = fixture_vm_class(header=header, chaindb=chaindb)
state = vm.state
apply_state_dict(state.account_db, fixture['pre'])
state.account_db.persist()
# Update state_root manually
vm.block = vm.block.copy(header=vm.block.header.copy(
state_root=state.state_root))
if 'secretKey' in fixture['transaction']:
unsigned_transaction = vm.create_unsigned_transaction(
nonce=fixture['transaction']['nonce'],
gas_price=fixture['transaction']['gasPrice'],
gas=fixture['transaction']['gasLimit'],
to=fixture['transaction']['to'],
value=fixture['transaction']['value'],
data=fixture['transaction']['data'],
)
private_key = keys.PrivateKey(fixture['transaction']['secretKey'])
transaction = unsigned_transaction.as_signed_transaction(
private_key=private_key)
elif 'vrs' in fixture['transaction']:
v, r, s = (
fixture['transaction']['v'],
fixture['transaction']['r'],
fixture['transaction']['s'],
)
transaction = vm.create_transaction(
nonce=fixture['transaction']['nonce'],
gas_price=fixture['transaction']['gasPrice'],
gas=fixture['transaction']['gasLimit'],
to=fixture['transaction']['to'],
value=fixture['transaction']['value'],
data=fixture['transaction']['data'],
v=v,
r=r,
s=s,
)
try:
header, receipt, computation = vm.apply_transaction(
vm.block.header, transaction)
transactions = vm.block.transactions + (transaction, )
receipts = vm.block.get_receipts(chaindb) + (receipt, )
block = vm.set_block_transactions(vm.block, header, transactions,
receipts)
except ValidationError as err:
block = vm.block
transaction_error = err
logger.warn("Got transaction error", exc_info=True)
else:
transaction_error = False
if not transaction_error:
log_entries = computation.get_log_entries()
actual_logs_hash = hash_log_entries(log_entries)
if 'logs' in fixture['post']:
expected_logs_hash = fixture['post']['logs']
assert expected_logs_hash == actual_logs_hash
elif log_entries:
raise AssertionError("Got log {0} entries. hash:{1}".format(
len(log_entries),
actual_logs_hash,
))
if 'out' in fixture:
expected_output = fixture['out']
if isinstance(expected_output, int):
assert len(computation.output) == expected_output
else:
assert computation.output == expected_output
assert block.header.state_root == fixture['post']['hash']
def private_key_to_address(private_key: bytes) -> Address:
private_key_object = keys.PrivateKey(private_key)
return Address(private_key_object.public_key.to_canonical_address())
def __init__(self, data: bytes) -> None:
self.__seckey = keys.PrivateKey(data)
def _create_v3_keyfile_json(private_key, password, kdf, work_factor=None):
salt = Random.get_random_bytes(16)
if work_factor is None:
work_factor = get_default_work_factor_for_kdf(kdf)
if kdf == 'pbkdf2':
derived_key = _pbkdf2_hash(
password,
hash_name='sha256',
salt=salt,
iterations=work_factor,
dklen=DKLEN,
)
kdfparams = {
'c': work_factor,
'dklen': DKLEN,
'prf': 'hmac-sha256',
'salt': encode_hex_no_prefix(salt),
}
elif kdf == 'scrypt':
derived_key = _scrypt_hash(
password,
salt=salt,
buflen=DKLEN,
r=SCRYPT_R,
p=SCRYPT_P,
n=work_factor,
)
kdfparams = {
'dklen': DKLEN,
'n': work_factor,
'r': SCRYPT_R,
'p': SCRYPT_P,
'salt': encode_hex_no_prefix(salt),
}
else:
raise NotImplementedError("KDF not implemented: {0}".format(kdf))
iv = big_endian_to_int(Random.get_random_bytes(16))
encrypt_key = derived_key[:16]
ciphertext = encrypt_aes_ctr(private_key, encrypt_key, iv)
mac = keccak(derived_key[16:32] + ciphertext)
address = keys.PrivateKey(private_key).public_key.to_address()
return {
'address': remove_0x_prefix(address),
'crypto': {
'cipher': 'aes-128-ctr',
'cipherparams': {
'iv': encode_hex_no_prefix(int_to_big_endian(iv)),
},
'ciphertext': encode_hex_no_prefix(ciphertext),
'kdf': kdf,
'kdfparams': kdfparams,
'mac': encode_hex_no_prefix(mac),
},
'id': str(uuid.uuid4()),
'version': 3,
}
def address_from_private_key(private_key):
if isinstance(private_key, str):
private_key = bytes.fromhex(private_key.replace('0x', ''))
return keys.PrivateKey(private_key).public_key.to_checksum_address()
def __init__(self, keyfile='', password='', private_key='', provider='', provider_endpoint_uri='',
contract_address='', contract_abi={}, gas_price=None, gas_limit=None):
"""Create a new instance of the Token SDK.
The SDK needs a JSON-RPC provider, contract definitions and (optionally) a wallet private key.
The user may pass either a provider or a provider endpoint URI, in which case a default
:class:`web3:providers:HTTPProvider` will be created. If neither private_key nor keyfile+password
are provided, the SDK can still be used in "anonymous" mode, with only the following functions available:
- get_address_ether_balance
- get_transaction_status
- get_transaction_data
- monitor_ether_transactions
:param str private_key: a private key to initialize the wallet with. If either private key or keyfile
are not provided, the wallet will not be initialized and methods needing the wallet will raise exception.
:param str keyfile: the path to the keyfile to initialize the wallet with. You will also need to supply
a password for this keyfile.
:param str password: a password for the keyfile.
:param provider: JSON-RPC provider to work with. If not given, a default `web3:providers:HTTPProvider`
is used, inited with provider_endpoint_uri.
:type provider: :class:`web3:providers:BaseProvider`
:param str provider_endpoint_uri: a URI to use with a default HTTPProvider.
:param str contract_address: the address of the token contract.
:param list contract_abi: The contract ABI json.
:param number gas_price: The price of gas in Gwei.
:param number gas_limit: Transaction gas limit.
:returns: An instance of the SDK.
:rtype: :class:`~erc20tokensdk.SDK`
:raises: :class:`~erc20tokensdk.exceptions.SdkConfigurationError` if some of the configuration
parameters are invalid.
"""
if not provider and not provider_endpoint_uri:
raise SdkConfigurationError('either provider or provider endpoint must be provided')
try:
validate_address(contract_address)
except ValueError as ve:
raise SdkConfigurationError('invalid token contract address: ' + str(ve))
try:
validate_abi(contract_abi)
except Exception as e:
raise SdkConfigurationError('invalid token contract abi: ' + str(e))
if gas_price and not (isinstance(gas_price, int) or isinstance(gas_price, float)):
raise SdkConfigurationError('gas price must be either integer of float')
if gas_limit and not isinstance(gas_limit, int):
raise SdkConfigurationError('gas limit must be integer')
if provider:
self.web3 = Web3(provider)
else:
self.web3 = Web3(RetryHTTPProvider(provider_endpoint_uri))
if not self.web3.isConnected():
raise SdkConfigurationError('cannot connect to provider endpoint')
self.token_contract = self.web3.eth.contract(contract_address, abi=contract_abi)
self.private_key = None
self.address = None
if keyfile:
try:
self.private_key = load_keyfile(keyfile, password)
except Exception as e:
raise SdkConfigurationError('cannot load keyfile: ' + str(e))
elif private_key:
self.private_key = private_key
if self.private_key:
try:
private_key_bytes = hexstr_if_str(to_bytes, self.private_key)
pk = keys.PrivateKey(private_key_bytes)
self.address = self.web3.eth.defaultAccount = pk.public_key.to_checksum_address()
except ValidationError as e:
raise SdkConfigurationError('cannot load private key: ' + str(e))
# init transaction manager
self._tx_manager = TransactionManager(self.web3, self.private_key, self.address, self.token_contract,
gas_price, gas_limit)
# monitoring filter manager
self._filter_mgr = FilterManager(self.web3)
async def test_handshake_eip8():
cancel_token = CancelToken("test_handshake_eip8")
use_eip8 = True
initiator_remote = kademlia.Node(
keys.PrivateKey(eip8_values['receiver_private_key']).public_key,
kademlia.Address('0.0.0.0', 0, 0))
initiator = HandshakeInitiator(
initiator_remote,
keys.PrivateKey(eip8_values['initiator_private_key']), use_eip8,
cancel_token)
initiator.ephemeral_privkey = keys.PrivateKey(
eip8_values['initiator_ephemeral_private_key'])
responder_remote = kademlia.Node(
keys.PrivateKey(eip8_values['initiator_private_key']).public_key,
kademlia.Address('0.0.0.0', 0, 0))
responder = HandshakeResponder(
responder_remote, keys.PrivateKey(eip8_values['receiver_private_key']),
use_eip8, cancel_token)
responder.ephemeral_privkey = keys.PrivateKey(
eip8_values['receiver_ephemeral_private_key'])
auth_init_ciphertext = eip8_values['auth_init_ciphertext']
# Check that we can decrypt/decode the EIP-8 auth init message.
initiator_ephemeral_pubkey, initiator_nonce, _ = decode_authentication(
auth_init_ciphertext, responder.privkey)
assert initiator_nonce == eip8_values['initiator_nonce']
assert initiator_ephemeral_pubkey == (keys.PrivateKey(
eip8_values['initiator_ephemeral_private_key']).public_key)
responder_nonce = eip8_values['receiver_nonce']
auth_ack_ciphertext = eip8_values['auth_ack_ciphertext']
aes_secret, mac_secret, egress_mac, ingress_mac = responder.derive_secrets(
initiator_nonce, responder_nonce, initiator_ephemeral_pubkey,
auth_init_ciphertext, auth_ack_ciphertext)
# Check that the secrets derived by the responder match the expected values.
assert aes_secret == eip8_values['expected_aes_secret']
assert mac_secret == eip8_values['expected_mac_secret']
# Also according to https://github.com/ethereum/EIPs/blob/master/EIPS/eip-8.md, running B's
# ingress-mac keccak state on the string "foo" yields the following hash:
ingress_mac_copy = ingress_mac.copy()
ingress_mac_copy.update(b'foo')
assert ingress_mac_copy.hexdigest() == (
'0c7ec6340062cc46f5e9f1e3cf86f8c8c403c5a0964f5df0ebd34a75ddc86db5')
responder_ephemeral_pubkey, responder_nonce = initiator.decode_auth_ack_message(
auth_ack_ciphertext)
(initiator_aes_secret, initiator_mac_secret, initiator_egress_mac,
initiator_ingress_mac) = initiator.derive_secrets(
initiator_nonce, responder_nonce, responder_ephemeral_pubkey,
auth_init_ciphertext, auth_ack_ciphertext)
# Check that the secrets derived by the initiator match the expected values.
assert initiator_aes_secret == eip8_values['expected_aes_secret']
assert initiator_mac_secret == eip8_values['expected_mac_secret']
# Finally, check that two Peers configured with the secrets generated above understand each
# other.
responder_reader = asyncio.StreamReader()
initiator_reader = asyncio.StreamReader()
# Link the initiator's writer to the responder's reader, and the responder's writer to the
# initiator's reader.
responder_writer = MockStreamWriter(initiator_reader.feed_data)
initiator_writer = MockStreamWriter(responder_reader.feed_data)
initiator_peer = DumbPeer(remote=initiator.remote,
privkey=initiator.privkey,
reader=initiator_reader,
writer=initiator_writer,
aes_secret=initiator_aes_secret,
mac_secret=initiator_mac_secret,
egress_mac=initiator_egress_mac,
ingress_mac=initiator_ingress_mac,
headerdb=None,
network_id=1)
initiator_peer.base_protocol.send_handshake()
responder_peer = DumbPeer(remote=responder.remote,
privkey=responder.privkey,
reader=responder_reader,
writer=responder_writer,
aes_secret=aes_secret,
mac_secret=mac_secret,
egress_mac=egress_mac,
ingress_mac=ingress_mac,
headerdb=None,
network_id=1)
responder_peer.base_protocol.send_handshake()
# The handshake msgs sent by each peer (above) are going to be fed directly into their remote's
# reader, and thus the read_msg() calls will return immediately.
responder_hello, _ = await responder_peer.read_msg()
initiator_hello, _ = await initiator_peer.read_msg()
assert isinstance(responder_hello, Hello)
assert isinstance(initiator_hello, Hello)
def test_state_fixtures(fixture, fixture_vm_class):
header = BlockHeader(
coinbase=fixture['env']['currentCoinbase'],
difficulty=fixture['env']['currentDifficulty'],
block_number=fixture['env']['currentNumber'],
gas_limit=fixture['env']['currentGasLimit'],
timestamp=fixture['env']['currentTimestamp'],
parent_hash=fixture['env']['previousHash'],
)
chaindb = ChainDB(get_db_backend())
vm = fixture_vm_class(header=header, chaindb=chaindb)
vm_state = vm.state
with vm_state.mutable_state_db() as state_db:
setup_state_db(fixture['pre'], state_db)
# Update state_root manually
vm.block.header.state_root = vm_state.state_root
if 'secretKey' in fixture['transaction']:
unsigned_transaction = vm.create_unsigned_transaction(
nonce=fixture['transaction']['nonce'],
gas_price=fixture['transaction']['gasPrice'],
gas=fixture['transaction']['gasLimit'],
to=fixture['transaction']['to'],
value=fixture['transaction']['value'],
data=fixture['transaction']['data'],
)
private_key = keys.PrivateKey(fixture['transaction']['secretKey'])
transaction = unsigned_transaction.as_signed_transaction(
private_key=private_key)
elif 'vrs' in fixture['transaction']:
v, r, s = (
fixture['transaction']['v'],
fixture['transaction']['r'],
fixture['transaction']['s'],
)
transaction = vm.create_transaction(
nonce=fixture['transaction']['nonce'],
gas_price=fixture['transaction']['gasPrice'],
gas=fixture['transaction']['gasLimit'],
to=fixture['transaction']['to'],
value=fixture['transaction']['value'],
data=fixture['transaction']['data'],
v=v,
r=r,
s=s,
)
try:
computation, _ = vm.apply_transaction(transaction)
except ValidationError as err:
transaction_error = err
LOGGER.warn("Got transaction error:")
LOGGER.warn(traceback.format_exc())
else:
transaction_error = False
if not transaction_error:
log_entries = computation.get_log_entries()
actual_logs_hash = hash_log_entries(log_entries)
if 'logs' in fixture['post']:
expected_logs_hash = fixture['post']['logs']
assert expected_logs_hash == actual_logs_hash
elif log_entries:
raise AssertionError("Got log {0} entries. hash:{1}".format(
len(log_entries),
actual_logs_hash,
))
if 'out' in fixture:
expected_output = fixture['out']
if isinstance(expected_output, int):
assert len(computation.output) == expected_output
else:
assert computation.output == expected_output
assert vm.block.header.state_root == fixture['post']['hash']
def funded_address_private_key():
return keys.PrivateKey(
decode_hex(
'0x45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8'
))
def from_seed(cls, seed: bytes, *args: Any,
**kwargs: Any) -> DiscoveryProtocol:
privkey = keys.PrivateKey(keccak(seed))
return cls(*args, privkey=privkey, **kwargs)
def privatekey_to_address(private_key_bin: bytes) -> Address:
return keys.PrivateKey(private_key_bin).public_key.to_canonical_address()
result = decode_message(encoded)
assert result == message
@given(num_enr_records=st.integers(min_value=0, max_value=5))
def test_found_nodes_message_encoding_round_trip(num_enr_records):
enrs = tuple(ENRFactory() for _ in range(num_enr_records))
encoded_enrs = tuple(rlp.encode(enr) for enr in enrs)
payload = FoundNodesPayload(num_enr_records, encoded_enrs)
message = FoundNodesMessage(payload)
encoded = message.to_wire_bytes()
result = decode_message(encoded)
assert result.payload == message.payload
PRIVATE_KEY = keys.PrivateKey(b"unicornsrainbowscupcakessparkles")
advertisement_st = st.tuples(
st.binary(min_size=1, max_size=128), st.binary(min_size=32, max_size=32),
).map(lambda key_and_root: Advertisement.create(*key_and_root, PRIVATE_KEY))
@settings(deadline=500)
@given(advertisements=st.lists(advertisement_st, min_size=1, max_size=5).map(tuple),)
def test_advertisement_message_encoding_round_trip(advertisements):
message = AdvertiseMessage(advertisements)
encoded = message.to_wire_bytes()
result = decode_message(encoded)
assert result == message
import random
from collections import namedtuple
import rlp
from eth_keys import keys
from eth_utils import decode_hex, keccak
from web3.datastructures import AttributeDict
SignedBlockHeader = namedtuple("SignedBlockHeader", "unsignedBlockHeader signature")
_PRIVATE_KEY_DEFAULT = keys.PrivateKey(b"1" * 32)
_TIMESTAMP_DEFAULT = 100
_random_generator = random.Random(0)
def random_hash():
return bytes(_random_generator.randint(0, 255) for _ in range(32))
def random_number():
return _random_generator.randint(0, 100)
def random_private_key():
return keys.PrivateKey(random_hash())
def make_short_block_header_list(block_header):
"""Order the first 11 block header fields into a list.
def web3js_private_key(web3js_key):
return keys.PrivateKey(HexBytes(web3js_key))
HexBytes("0x13978aee95f38490e9769C39B2773Ed763d9cd5F"),
"value":
10000000000000000,
"data":
"",
"unsigned":
"eb8085e8d4a510008227109413978aee95f38490e9769c39b2773ed763d9cd5f872386f26fc1000080808080", # noqa: 501
"signed":
"f86b8085e8d4a510008227109413978aee95f38490e9769c39b2773ed763d9cd5f872386f26fc10000801ba0eab47c1a49bf2fe5d40e01d313900e19ca485867d462fe06e139e3a536c6d4f4a014a569d327dcda4b29f74f93c0e9729d2f49ad726e703f9cd90dbb0fbf6649f1" # noqa: 501
},
]
PRIVATE_KEY_AS_BYTES = b'unicorns' * 4
PRIVATE_KEY_AS_HEXSTR = '0x756e69636f726e73756e69636f726e73756e69636f726e73756e69636f726e73'
PRIVATE_KEY_AS_INT = 0x756e69636f726e73756e69636f726e73756e69636f726e73756e69636f726e73
PRIVATE_KEY_AS_OBJ = keys.PrivateKey(PRIVATE_KEY_AS_BYTES)
ACCT_ADDRESS = '0xa79F6f349C853F9Ea0B29636779ae3Cb4E3BA729'
PRIVATE_KEY_AS_BYTES_ALT = b'rainbows' * 4
PRIVATE_KEY_AS_HEXSTR_ALT = '0x7261696e626f77737261696e626f77737261696e626f77737261696e626f7773'
PRIVATE_KEY_AS_INT_ALT = 0x7261696e626f77737261696e626f77737261696e626f77737261696e626f7773
PRIVATE_KEY_AS_OBJ_ALT = keys.PrivateKey(PRIVATE_KEY_AS_BYTES_ALT)
ACCT_ADDRESS_ALT = '0xafd7f0E16A1814B854b45f551AFD493BE5F039F9'
@pytest.fixture(params=[
PRIVATE_KEY_AS_INT, PRIVATE_KEY_AS_HEXSTR, PRIVATE_KEY_AS_BYTES,
PRIVATE_KEY_AS_OBJ
]) # noqa: 501
def PRIVATE_KEY(request):
return request.param
def generate_privkey() -> datatypes.PrivateKey:
"""Generate a new SECP256K1 private key and return it"""
privkey = ec.generate_private_key(CURVE, default_backend())
return keys.PrivateKey(
pad32(int_to_big_endian(privkey.private_numbers().private_value)))
from tests.trinity.core.integration_test_helpers import FakeAsyncHeaderDB
def get_open_port():
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(("", 0))
s.listen(1)
port = s.getsockname()[1]
s.close()
return port
port = get_open_port()
NETWORK_ID = 99
SERVER_ADDRESS = Address('127.0.0.1', udp_port=port, tcp_port=port)
RECEIVER_PRIVKEY = keys.PrivateKey(eip8_values['receiver_private_key'])
RECEIVER_PUBKEY = RECEIVER_PRIVKEY.public_key
RECEIVER_REMOTE = Node(RECEIVER_PUBKEY, SERVER_ADDRESS)
INITIATOR_PRIVKEY = keys.PrivateKey(eip8_values['initiator_private_key'])
INITIATOR_PUBKEY = INITIATOR_PRIVKEY.public_key
INITIATOR_ADDRESS = Address('127.0.0.1', get_open_port() + 1)
INITIATOR_REMOTE = Node(INITIATOR_PUBKEY, INITIATOR_ADDRESS)
class MockPeerPool:
is_full = False
connected_nodes = {}
def __init__(self):
self._new_peers = asyncio.Queue()
def private_key_to_account(pk: str):
from eth_keys import keys
from web3 import Web3
account = keys.PrivateKey(Web3.toBytes(hexstr=pk))
return account.public_key.to_checksum_address()
