def test_transform_cbor_to_dict_with_multiaddr(): addr1 = Multiaddr('/ip4/127.0.0.1/udp/1234') addr2 = Multiaddr('/ipfs/Qmafmh1Cw3H1bwdYpaaj5AbCW4LkYyUWaM7Nykpn5NZoYL') src = dumps({ 'data': 'hello world', 'size': 11, 'l1': Tag(LINK_TAG, addr1.to_bytes()), 'l2': Tag(LINK_TAG, addr2.to_bytes()), }, sort_keys=True) expected = { 'data': 'hello world', 'size': 11, 'l1': { '/': str(addr1), }, 'l2': { '/': str(addr2), } } assert unmarshal(src) == expected
def __init__(self, client: Client, listen_maddr: Multiaddr = None) -> None: if listen_maddr is None: listen_maddr = Multiaddr(config.listen_maddr_str) self.listen_maddr = listen_maddr self.client = client self.handlers = {}
from multiaddr import Multiaddr from libp2p import Libp2p l = Libp2p('/tmp/p2pd.sock') [i, a] = l.identify() print("Identity: ", i) print("Multiaddrs: ", a) ma = Multiaddr(string_addr='/ip4/104.131.131.82/tcp/4001') l.connect('QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ', [ma])
def p2p_maddr(): return Multiaddr("/ip4/127.0.0.1/tcp/13000")
def from_protobuf(cls, pb_msg: p2pd_pb2.StreamInfo) -> "StreamInfo": stream_info = cls(peer_id=PeerID(pb_msg.peer), addr=Multiaddr(pb_msg.addr), proto=pb_msg.proto) return stream_info
def maddr(self) -> Multiaddr: return Multiaddr( f"/ip4/127.0.0.1/tcp/{self.port}/p2p/{self.peer_id.to_base58()}")
def listen_maddr_with_peer_id(self) -> Multiaddr: return self.listen_maddr.encapsulate(Multiaddr(f"/p2p/{self.peer_id.to_base58()}"))
def from_pb(cls, peer_info_pb: p2pd_pb2.PeerInfo) -> PeerInfoLibP2P: peer_id = ID(peer_info_pb.id) addrs = [Multiaddr(addr) for addr in peer_info_pb.addrs] return PeerInfoLibP2P(peer_id, addrs)
def test_client_ctor_default_control_maddr(): c = Client() assert c.control_maddr == Multiaddr(config.control_maddr_str)
def test_client_ctor_control_maddr(control_maddr_str): c = Client(Multiaddr(control_maddr_str)) assert c.control_maddr == Multiaddr(control_maddr_str)
def test_parse_conn_protocol_invalid(maddr_str): maddr = Multiaddr(maddr_str) with pytest.raises(ValueError): parse_conn_protocol(maddr)
def test_parse_conn_protocol_valid(maddr_str, expected_proto): assert parse_conn_protocol(Multiaddr(maddr_str)) == expected_proto
def _derive_port(maddr: Multiaddr, orchestration_profile: str) -> Multiaddr: offset = ord(orchestration_profile[:1]) - ord("a") port = int(maddr.value_for_protocol("tcp")) + offset return Multiaddr.join(f"/ip4/{maddr.value_for_protocol('ip4')}", f"/tcp/{port}")
def __init__( self, local_node_key: PrivateKey, eth2_config: Eth2Config, clock: Clock, chain: BaseBeaconChain, validator_api_port: int, client_identifier: str, p2p_maddr: Multiaddr, preferred_nodes: Collection[Multiaddr], bootstrap_nodes: Collection[Multiaddr], ) -> None: self._local_key_pair = create_new_key_pair(local_node_key.to_bytes()) self._eth2_config = eth2_config self._clock = clock self._chain = chain self._block_pool: Set[SignedBeaconBlock] = set() self._slashable_block_pool: Set[SignedBeaconBlock] = set() # FIXME: can we provide `p2p_maddr` as a default listening interface for `_mk_host`? peer_id = PeerID.from_pubkey(self._local_key_pair.public_key) if "p2p" in p2p_maddr: existing_peer_id = p2p_maddr.value_for_protocol("p2p") existing_p2p_maddr = Multiaddr(f"/p2p/{existing_peer_id}") self.logger.warning( "peer identity derived from local key pair %s overriding given identity %s", peer_id, existing_peer_id, ) p2p_maddr = p2p_maddr.decapsulate(existing_p2p_maddr) self._p2p_maddr = p2p_maddr.encapsulate(Multiaddr(f"/p2p/{peer_id}")) # TODO: persist metadata and handle updates... self._metadata_provider = lambda: MetaData.create() self._peer_updater, self._peer_updates = trio.open_memory_channel[ Tuple[PeerID, Any]](0) self._host = Host( self._local_key_pair, peer_id, self._accept_peer_updates, self._get_status, self._get_finalized_root_by_epoch, self._get_block_by_slot, self._get_block_by_root, self._metadata_provider, self._get_fork_digest, self._eth2_config, ) self._preferred_nodes = preferred_nodes self._bootstrap_nodes = bootstrap_nodes self._sync_notifier, self._sync_requests = trio.open_memory_channel[ SyncRequest](0) self._syncer = _mk_syncer() api_context = Context( client_identifier, eth2_config, self._syncer, self._chain, self._clock, _mk_block_broadcaster(self), ) self.validator_api_port = validator_api_port self._validator_api_server = _mk_validator_api_server( self.validator_api_port, api_context)
def test_control_client_ctor_listen_maddr(listen_maddr_str): c = ControlClient(client=Client(), listen_maddr=Multiaddr(listen_maddr_str)) assert c.listen_maddr == Multiaddr(listen_maddr_str)
def _multiaddr_from_socket(socket: socket) -> Multiaddr: return Multiaddr("/ip4/%s/tcp/%s" % socket.getsockname())
def test_control_client_ctor_default_listen_maddr(): c = ControlClient(client=Client()) assert c.listen_maddr == Multiaddr(config.listen_maddr_str)
def _multiaddr_from_socket(socket: trio.socket.SocketType) -> Multiaddr: ip, port = socket.getsockname() # type: ignore return Multiaddr(f"/ip4/{ip}/tcp/{port}")
def __init__(self, addr:str,port:int): self.client=Client(Multiaddr(addr)) log("Adresse du client IPFS: " + addr)
def _parse_multiaddrs_from_args(multiaddrs: str) -> Iterable[Multiaddr]: for multiaddr in multiaddrs.split(","): yield Multiaddr(multiaddr.strip())
def from_pb(cls, peer_info_pb: p2pd_pb2.PeerInfo) -> 'PeerInfo': peer_id = PeerID(peer_info_pb.id) addrs = [ Multiaddr(binascii.hexlify(addr)) for addr in peer_info_pb.addrs ] return cls(peer_id, addrs)
def __init__(self, control_maddr: Multiaddr = None) -> None: if control_maddr is None: control_maddr = Multiaddr(config.control_maddr_str) self.control_maddr = control_maddr
def _multiaddr_to_bytes(maddr: Multiaddr) -> bytes: return maddr.to_bytes()
def from_protobuf(cls, peer_info_pb: p2pd_pb2.PeerInfo) -> "PeerInfo": peer_id = PeerID(peer_info_pb.id) addrs = [Multiaddr(addr) for addr in peer_info_pb.addrs] return PeerInfo(peer_id, addrs)
def make_tcp_ip_maddr(ip: str, port: int) -> Multiaddr: return Multiaddr(f"/ip4/{ip}/tcp/{port}")
def maddr(): return Multiaddr('/unix/123')
def maddr(): return Multiaddr("/unix/123")