web-dc-api 0.0.58 → 0.0.60

package/dist/esm/node_modules/@libp2p/dcutr/dist/src/index.js

@@ -0,0 +1,68 @@
+import { DefaultDCUtRService } from './dcutr.js';
+
+/**
+ * @packageDocumentation
+ *
+ * Direct Connection Upgrade through Relay (DCUtR) is a protocol that allows two
+ * nodes to connect to each other who would otherwise be prevented doing so due
+ * to being behind NATed connections or firewalls.
+ *
+ * The protocol involves making a relayed connection between the two peers and
+ * using the relay to synchronize connection timings so that they dial each other
+ * at precisely the same moment.
+ *
+ * @example
+ *
+ * ```TypeScript
+ * import { createLibp2p } from 'libp2p'
+ * import { circuitRelayTransport } from '@libp2p/circuit-relay-v2'
+ * import { tcp } from '@libp2p/tcp'
+ * import { identify } from '@libp2p/identify'
+ * import { dcutr } from '@libp2p/dcutr'
+ * import { multiaddr } from '@multiformats/multiaddr'
+ *
+ * const node = await createLibp2p({
+ *   transports: [
+ *     circuitRelayTransport(),
+ *     tcp()
+ *   ],
+ *   services: {
+ *     identify: identify(),
+ *     dcutr: dcutr()
+ *   }
+ * })
+ *
+ * // QmTarget is a peer that is behind a NAT, supports TCP and has a relay
+ * // reservation
+ * const ma = multiaddr('/ip4/.../p2p/QmRelay/p2p-circuit/p2p/QmTarget')
+ * await node.dial(ma)
+ *
+ * // after a while the connection should automatically get upgraded to a
+ * // direct connection (e.g. non-limited)
+ * while (true) {
+ *   const connections = node.getConnections()
+ *
+ *   if (connections.find(conn => conn.limits == null)) {
+ *     console.info('have direct connection')
+ *     break
+ *   } else {
+ *     console.info('have relayed connection')
+ *
+ *     // wait a few seconds to see if it's succeeded yet
+ *     await new Promise<void>((resolve) => {
+ *       setTimeout(() => resolve(), 5000)
+ *     })
+ *   }
+ * }
+ * ```
+ */
+/**
+ * The DCUtR protocol
+ */
+const multicodec = '/libp2p/dcutr';
+function dcutr() {
+  let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return components => new DefaultDCUtRService(components, init);
+}
+
+export { dcutr, multicodec };

package/dist/esm/node_modules/@libp2p/dcutr/dist/src/pb/message.js

@@ -0,0 +1,88 @@
+import { MaxLengthError } from '../../../../../protons-runtime/dist/src/index.js';
+import { enumeration } from '../../../../../protons-runtime/dist/src/codecs/enum.js';
+import { message } from '../../../../../protons-runtime/dist/src/codecs/message.js';
+import { encodeMessage } from '../../../../../protons-runtime/dist/src/encode.js';
+import { decodeMessage } from '../../../../../protons-runtime/dist/src/decode.js';
+
+var HolePunch;
+(function (HolePunch) {
+  (function (Type) {
+    Type["UNUSED"] = "UNUSED";
+    Type["CONNECT"] = "CONNECT";
+    Type["SYNC"] = "SYNC";
+  })(HolePunch.Type || (HolePunch.Type = {}));
+  let __TypeValues;
+  (function (__TypeValues) {
+    __TypeValues[__TypeValues["UNUSED"] = 0] = "UNUSED";
+    __TypeValues[__TypeValues["CONNECT"] = 100] = "CONNECT";
+    __TypeValues[__TypeValues["SYNC"] = 300] = "SYNC";
+  })(__TypeValues || (__TypeValues = {}));
+  (function (Type) {
+    Type.codec = () => {
+      return enumeration(__TypeValues);
+    };
+  })(HolePunch.Type || (HolePunch.Type = {}));
+  let _codec;
+  HolePunch.codec = () => {
+    if (_codec == null) {
+      _codec = message(function (obj, w) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        if (opts.lengthDelimited !== false) {
+          w.fork();
+        }
+        if (obj.type != null) {
+          w.uint32(8);
+          HolePunch.Type.codec().encode(obj.type, w);
+        }
+        if (obj.observedAddresses != null) {
+          for (const value of obj.observedAddresses) {
+            w.uint32(18);
+            w.bytes(value);
+          }
+        }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim();
+        }
+      }, function (reader, length) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        const obj = {
+          observedAddresses: []
+        };
+        const end = length == null ? reader.len : reader.pos + length;
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1:
+              {
+                obj.type = HolePunch.Type.codec().decode(reader);
+                break;
+              }
+            case 2:
+              {
+                if (opts.limits?.observedAddresses != null && obj.observedAddresses.length === opts.limits.observedAddresses) {
+                  throw new MaxLengthError('Decode error - map field "observedAddresses" had too many elements');
+                }
+                obj.observedAddresses.push(reader.bytes());
+                break;
+              }
+            default:
+              {
+                reader.skipType(tag & 7);
+                break;
+              }
+          }
+        }
+        return obj;
+      });
+    }
+    return _codec;
+  };
+  HolePunch.encode = obj => {
+    return encodeMessage(obj, HolePunch.codec());
+  };
+  HolePunch.decode = (buf, opts) => {
+    return decodeMessage(buf, HolePunch.codec(), opts);
+  };
+})(HolePunch || (HolePunch = {}));
+
+export { HolePunch };

package/dist/esm/node_modules/@libp2p/dcutr/dist/src/utils.js

@@ -0,0 +1,28 @@
+import { isPrivateIp } from '../../../utils/dist/src/private-ip.js';
+import { Circuit, DNS, IP } from '../../../../@multiformats/multiaddr-matcher/dist/src/index.js';
+
+/**
+ * Returns true if the passed multiaddr is public, not relayed and we have a
+ * transport that can dial it
+ */
+function isPublicAndDialable(ma, transportManager) {
+  // ignore circuit relay
+  if (Circuit.matches(ma)) {
+    return false;
+  }
+  const transport = transportManager.dialTransportForMultiaddr(ma);
+  if (transport == null) {
+    return false;
+  }
+  // dns addresses are probably public?
+  if (DNS.matches(ma)) {
+    return true;
+  }
+  // ensure we have only IPv4/IPv6 addresses
+  if (!IP.matches(ma)) {
+    return false;
+  }
+  return isPrivateIp(ma.toOptions().host) === false;
+}
+
+export { isPublicAndDialable };

package/dist/esm/node_modules/@libp2p/identify/dist/src/consts.js

@@ -0,0 +1,11 @@
+const IDENTIFY_PROTOCOL_VERSION = '0.1.0';
+const MULTICODEC_IDENTIFY_PROTOCOL_NAME = 'id';
+const MULTICODEC_IDENTIFY_PUSH_PROTOCOL_NAME = 'id/push';
+const MULTICODEC_IDENTIFY_PROTOCOL_VERSION = '1.0.0';
+const MULTICODEC_IDENTIFY_PUSH_PROTOCOL_VERSION = '1.0.0';
+// https://github.com/libp2p/go-libp2p/blob/8d2e54e1637041d5cf4fac1e531287560bd1f4ac/p2p/protocol/identify/id.go#L52
+const MAX_IDENTIFY_MESSAGE_SIZE = 1024 * 8;
+// https://github.com/libp2p/go-libp2p/blob/0385ec924bad172f74a74db09939e97c079b1420/p2p/protocol/identify/id.go#L47C7-L47C25
+const MAX_PUSH_CONCURRENCY = 32;
+
+export { IDENTIFY_PROTOCOL_VERSION, MAX_IDENTIFY_MESSAGE_SIZE, MAX_PUSH_CONCURRENCY, MULTICODEC_IDENTIFY_PROTOCOL_NAME, MULTICODEC_IDENTIFY_PROTOCOL_VERSION, MULTICODEC_IDENTIFY_PUSH_PROTOCOL_NAME, MULTICODEC_IDENTIFY_PUSH_PROTOCOL_VERSION };

package/dist/esm/node_modules/@libp2p/identify/dist/src/identify-push.js

@@ -0,0 +1,127 @@
+import { serviceCapabilities, setMaxListeners } from '@libp2p/interface';
+import { protocols } from '@multiformats/multiaddr';
+import drain from '../../../../it-drain/dist/src/index.js';
+import parallel from '../../../../it-parallel/dist/src/index.js';
+import { pbStream } from '../../../../it-protobuf-stream/dist/src/index.js';
+import { fromString } from '../../../../uint8arrays/dist/src/from-string.js';
+import { toString } from '../../../../uint8arrays/dist/src/to-string.js';
+import { MULTICODEC_IDENTIFY_PUSH_PROTOCOL_NAME, MULTICODEC_IDENTIFY_PUSH_PROTOCOL_VERSION } from './consts.js';
+import { Identify as Identify$1 } from './pb/message.js';
+import { AbstractIdentify, defaultValues, consumeIdentifyMessage } from './utils.js';
+import { PeerRecord } from '../../../peer-record/dist/src/peer-record/index.js';
+import { RecordEnvelope } from '../../../peer-record/dist/src/envelope/index.js';
+
+class IdentifyPush extends AbstractIdentify {
+  connectionManager;
+  concurrency;
+  constructor(components) {
+    let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    super(components, {
+      ...init,
+      protocol: `/${init.protocolPrefix ?? defaultValues.protocolPrefix}/${MULTICODEC_IDENTIFY_PUSH_PROTOCOL_NAME}/${MULTICODEC_IDENTIFY_PUSH_PROTOCOL_VERSION}`,
+      log: components.logger.forComponent('libp2p:identify-push')
+    });
+    this.connectionManager = components.connectionManager;
+    this.concurrency = init.concurrency ?? defaultValues.concurrency;
+    if (init.runOnSelfUpdate ?? defaultValues.runOnSelfUpdate) {
+      // When self peer record changes, trigger identify-push
+      components.events.addEventListener('self:peer:update', evt => {
+        void this.push().catch(err => {
+          this.log.error(err);
+        });
+      });
+    }
+  }
+  [serviceCapabilities] = ['@libp2p/identify-push'];
+  /**
+   * Calls `push` on all peer connections
+   */
+  async push() {
+    // Do not try to push if we are not running
+    if (!this.isStarted()) {
+      return;
+    }
+    const listenAddresses = this.addressManager.getAddresses().map(ma => ma.decapsulateCode(protocols('p2p').code));
+    const peerRecord = new PeerRecord({
+      peerId: this.peerId,
+      multiaddrs: listenAddresses
+    });
+    const signedPeerRecord = await RecordEnvelope.seal(peerRecord, this.privateKey);
+    const supportedProtocols = this.registrar.getProtocols();
+    const peer = await this.peerStore.get(this.peerId);
+    const agentVersion = toString(peer.metadata.get('AgentVersion') ?? fromString(this.host.agentVersion));
+    const protocolVersion = toString(peer.metadata.get('ProtocolVersion') ?? fromString(this.host.protocolVersion));
+    const self = this;
+    async function* pushToConnections() {
+      for (const connection of self.connectionManager.getConnections()) {
+        const peer = await self.peerStore.get(connection.remotePeer);
+        if (!peer.protocols.includes(self.protocol)) {
+          continue;
+        }
+        yield async () => {
+          let stream;
+          const signal = AbortSignal.timeout(self.timeout);
+          setMaxListeners(Infinity, signal);
+          try {
+            stream = await connection.newStream(self.protocol, {
+              signal,
+              runOnLimitedConnection: self.runOnLimitedConnection
+            });
+            const pb = pbStream(stream, {
+              maxDataLength: self.maxMessageSize
+            }).pb(Identify$1);
+            await pb.write({
+              listenAddrs: listenAddresses.map(ma => ma.bytes),
+              signedPeerRecord: signedPeerRecord.marshal(),
+              protocols: supportedProtocols,
+              agentVersion,
+              protocolVersion
+            }, {
+              signal
+            });
+            await stream.close({
+              signal
+            });
+          } catch (err) {
+            // Just log errors
+            self.log.error('could not push identify update to peer', err);
+            stream?.abort(err);
+          }
+        };
+      }
+    }
+    await drain(parallel(pushToConnections(), {
+      concurrency: this.concurrency
+    }));
+  }
+  /**
+   * Reads the Identify Push message from the given `connection`
+   */
+  async handleProtocol(data) {
+    const {
+      connection,
+      stream
+    } = data;
+    try {
+      if (this.peerId.equals(connection.remotePeer)) {
+        throw new Error('received push from ourselves?');
+      }
+      const options = {
+        signal: AbortSignal.timeout(this.timeout)
+      };
+      const pb = pbStream(stream, {
+        maxDataLength: this.maxMessageSize
+      }).pb(Identify$1);
+      const message = await pb.read(options);
+      await stream.close(options);
+      await consumeIdentifyMessage(this.peerStore, this.events, this.log, connection, message);
+    } catch (err) {
+      this.log.error('received invalid message', err);
+      stream.abort(err);
+      return;
+    }
+    this.log.trace('handled push from %p', connection.remotePeer);
+  }
+}
+
+export { IdentifyPush };

package/dist/esm/node_modules/@libp2p/identify/dist/src/identify.js

@@ -0,0 +1,165 @@
+import { publicKeyFromProtobuf, publicKeyToProtobuf } from '../../../crypto/dist/src/keys/index.js';
+import { UnsupportedProtocolError, serviceCapabilities, setMaxListeners, InvalidMessageError } from '@libp2p/interface';
+import { peerIdFromCID } from '@libp2p/peer-id';
+import { isGlobalUnicast } from '../../../utils/dist/src/multiaddr/is-global-unicast.js';
+import { isPrivate } from '../../../utils/dist/src/multiaddr/is-private.js';
+import { protocols } from '@multiformats/multiaddr';
+import { TCP, IP_OR_DOMAIN } from '../../../../@multiformats/multiaddr-matcher/dist/src/index.js';
+import { pbStream } from '../../../../it-protobuf-stream/dist/src/index.js';
+import { MULTICODEC_IDENTIFY_PROTOCOL_NAME, MULTICODEC_IDENTIFY_PROTOCOL_VERSION } from './consts.js';
+import { Identify as Identify$1 } from './pb/message.js';
+import { AbstractIdentify, defaultValues, consumeIdentifyMessage, getCleanMultiaddr } from './utils.js';
+import { PeerRecord } from '../../../peer-record/dist/src/peer-record/index.js';
+import { RecordEnvelope } from '../../../peer-record/dist/src/envelope/index.js';
+
+const CODEC_IP6 = 0x29;
+class Identify extends AbstractIdentify {
+  constructor(components) {
+    let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    super(components, {
+      ...init,
+      protocol: `/${init.protocolPrefix ?? defaultValues.protocolPrefix}/${MULTICODEC_IDENTIFY_PROTOCOL_NAME}/${MULTICODEC_IDENTIFY_PROTOCOL_VERSION}`,
+      log: components.logger.forComponent('libp2p:identify')
+    });
+    if (init.runOnConnectionOpen ?? defaultValues.runOnConnectionOpen) {
+      // When a new connection happens, trigger identify
+      components.events.addEventListener('connection:open', evt => {
+        const connection = evt.detail;
+        this.identify(connection).catch(err => {
+          if (err.name === UnsupportedProtocolError.name) {
+            // the remote did not support identify, ignore the error
+            return;
+          }
+          this.log.error('error during identify trigged by connection:open', err);
+        });
+      });
+    }
+  }
+  [serviceCapabilities] = ['@libp2p/identify'];
+  async _identify(connection) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    let stream;
+    if (options.signal == null) {
+      const signal = AbortSignal.timeout(this.timeout);
+      setMaxListeners(Infinity, signal);
+      options = {
+        ...options,
+        signal
+      };
+    }
+    try {
+      stream = await connection.newStream(this.protocol, {
+        ...options,
+        runOnLimitedConnection: this.runOnLimitedConnection
+      });
+      const pb = pbStream(stream, {
+        maxDataLength: this.maxMessageSize
+      }).pb(Identify$1);
+      const message = await pb.read(options);
+      await stream.close(options);
+      return message;
+    } catch (err) {
+      stream?.abort(err);
+      throw err;
+    }
+  }
+  async identify(connection) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const message = await this._identify(connection, options);
+    const {
+      publicKey,
+      protocols,
+      observedAddr
+    } = message;
+    if (publicKey == null) {
+      throw new InvalidMessageError('public key was missing from identify message');
+    }
+    const key = publicKeyFromProtobuf(publicKey);
+    const id = peerIdFromCID(key.toCID());
+    if (!connection.remotePeer.equals(id)) {
+      throw new InvalidMessageError('identified peer does not match the expected peer');
+    }
+    if (this.peerId.equals(id)) {
+      throw new InvalidMessageError('identified peer is our own peer id?');
+    }
+    // if the observed address is publicly routable, add it to the address
+    // manager for verification via AutoNAT
+    this.maybeAddObservedAddress(observedAddr);
+    this.log('identify completed for peer %p and protocols %o', id, protocols);
+    return consumeIdentifyMessage(this.peerStore, this.events, this.log, connection, message);
+  }
+  maybeAddObservedAddress(observedAddr) {
+    const cleanObservedAddr = getCleanMultiaddr(observedAddr);
+    if (cleanObservedAddr == null) {
+      return;
+    }
+    this.log.trace('our observed address was %a', cleanObservedAddr);
+    if (isPrivate(cleanObservedAddr)) {
+      this.log.trace('our observed address was private');
+      return;
+    }
+    const tuples = cleanObservedAddr.stringTuples();
+    if (tuples[0][0] === CODEC_IP6 && !isGlobalUnicast(cleanObservedAddr)) {
+      this.log.trace('our observed address was IPv6 but not a global unicast address');
+      return;
+    }
+    if (TCP.exactMatch(cleanObservedAddr)) {
+      // TODO: because socket dials can't use the same local port as the TCP
+      // listener, many unique observed addresses are reported so ignore all
+      // TCP addresses until https://github.com/libp2p/js-libp2p/issues/2620
+      // is resolved
+      return;
+    }
+    this.log.trace('storing the observed address');
+    this.addressManager.addObservedAddr(cleanObservedAddr);
+  }
+  /**
+   * Sends the `Identify` response with the Signed Peer Record
+   * to the requesting peer over the given `connection`
+   */
+  async handleProtocol(data) {
+    const {
+      connection,
+      stream
+    } = data;
+    const signal = AbortSignal.timeout(this.timeout);
+    setMaxListeners(Infinity, signal);
+    try {
+      const peerData = await this.peerStore.get(this.peerId);
+      const multiaddrs = this.addressManager.getAddresses().map(ma => ma.decapsulateCode(protocols('p2p').code));
+      let signedPeerRecord = peerData.peerRecordEnvelope;
+      if (multiaddrs.length > 0 && signedPeerRecord == null) {
+        const peerRecord = new PeerRecord({
+          peerId: this.peerId,
+          multiaddrs
+        });
+        const envelope = await RecordEnvelope.seal(peerRecord, this.privateKey);
+        signedPeerRecord = envelope.marshal().subarray();
+      }
+      let observedAddr = connection.remoteAddr.bytes;
+      if (!IP_OR_DOMAIN.matches(connection.remoteAddr)) {
+        observedAddr = undefined;
+      }
+      const pb = pbStream(stream).pb(Identify$1);
+      await pb.write({
+        protocolVersion: this.host.protocolVersion,
+        agentVersion: this.host.agentVersion,
+        publicKey: publicKeyToProtobuf(this.privateKey.publicKey),
+        listenAddrs: multiaddrs.map(addr => addr.bytes),
+        signedPeerRecord,
+        observedAddr,
+        protocols: peerData.protocols
+      }, {
+        signal
+      });
+      await stream.close({
+        signal
+      });
+    } catch (err) {
+      this.log.error('could not respond to identify request', err);
+      stream.abort(err);
+    }
+  }
+}
+
+export { Identify };

package/dist/esm/node_modules/@libp2p/identify/dist/src/index.js

@@ -0,0 +1,55 @@
+import { IdentifyPush } from './identify-push.js';
+import { Identify } from './identify.js';
+
+/**
+ * @packageDocumentation
+ *
+ * Use the `identify` function to add support for the [Identify protocol](https://github.com/libp2p/specs/blob/master/identify/README.md) to libp2p.
+ *
+ * This protocol allows network peers to discover the multiaddrs the current node listens on, and the protocols it supports.
+ *
+ * A second function, `identifyPush` is also exported to add support for [identify/push](https://github.com/libp2p/specs/blob/master/identify/README.md#identifypush).
+ *
+ * This protocol will send updates to all connected peers when the multiaddrs or protocols of the current node change.
+ *
+ * > [!TIP]
+ * > For maximum network compatibility you should configure both protocols
+ *
+ * @example Enabling identify
+ *
+ * ```typescript
+ * import { createLibp2p } from 'libp2p'
+ * import { identify } from '@libp2p/identify'
+ *
+ * const node = await createLibp2p({
+ *   // ...other options
+ *   services: {
+ *     identify: identify()
+ *   }
+ * })
+ * ```
+ *
+ * @example Enabling identify push
+ *
+ * ```typescript
+ * import { createLibp2p } from 'libp2p'
+ * import { identifyPush } from '@libp2p/identify'
+ *
+ * const node = await createLibp2p({
+ *   // ...other options
+ *   services: {
+ *     identifyPush: identifyPush()
+ *   }
+ * })
+ * ```
+ */
+function identify() {
+  let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return components => new Identify(components, init);
+}
+function identifyPush() {
+  let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return components => new IdentifyPush(components, init);
+}
+
+export { identify, identifyPush };

package/dist/esm/node_modules/@libp2p/identify/dist/src/pb/message.js

@@ -0,0 +1,122 @@
+import { MaxLengthError } from '../../../../../protons-runtime/dist/src/index.js';
+import { message } from '../../../../../protons-runtime/dist/src/codecs/message.js';
+import { encodeMessage } from '../../../../../protons-runtime/dist/src/encode.js';
+import { decodeMessage } from '../../../../../protons-runtime/dist/src/decode.js';
+
+var Identify$1;
+(function (Identify) {
+  let _codec;
+  Identify.codec = () => {
+    if (_codec == null) {
+      _codec = message(function (obj, w) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        if (opts.lengthDelimited !== false) {
+          w.fork();
+        }
+        if (obj.protocolVersion != null) {
+          w.uint32(42);
+          w.string(obj.protocolVersion);
+        }
+        if (obj.agentVersion != null) {
+          w.uint32(50);
+          w.string(obj.agentVersion);
+        }
+        if (obj.publicKey != null) {
+          w.uint32(10);
+          w.bytes(obj.publicKey);
+        }
+        if (obj.listenAddrs != null) {
+          for (const value of obj.listenAddrs) {
+            w.uint32(18);
+            w.bytes(value);
+          }
+        }
+        if (obj.observedAddr != null) {
+          w.uint32(34);
+          w.bytes(obj.observedAddr);
+        }
+        if (obj.protocols != null) {
+          for (const value of obj.protocols) {
+            w.uint32(26);
+            w.string(value);
+          }
+        }
+        if (obj.signedPeerRecord != null) {
+          w.uint32(66);
+          w.bytes(obj.signedPeerRecord);
+        }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim();
+        }
+      }, function (reader, length) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        const obj = {
+          listenAddrs: [],
+          protocols: []
+        };
+        const end = length == null ? reader.len : reader.pos + length;
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 5:
+              {
+                obj.protocolVersion = reader.string();
+                break;
+              }
+            case 6:
+              {
+                obj.agentVersion = reader.string();
+                break;
+              }
+            case 1:
+              {
+                obj.publicKey = reader.bytes();
+                break;
+              }
+            case 2:
+              {
+                if (opts.limits?.listenAddrs != null && obj.listenAddrs.length === opts.limits.listenAddrs) {
+                  throw new MaxLengthError('Decode error - map field "listenAddrs" had too many elements');
+                }
+                obj.listenAddrs.push(reader.bytes());
+                break;
+              }
+            case 4:
+              {
+                obj.observedAddr = reader.bytes();
+                break;
+              }
+            case 3:
+              {
+                if (opts.limits?.protocols != null && obj.protocols.length === opts.limits.protocols) {
+                  throw new MaxLengthError('Decode error - map field "protocols" had too many elements');
+                }
+                obj.protocols.push(reader.string());
+                break;
+              }
+            case 8:
+              {
+                obj.signedPeerRecord = reader.bytes();
+                break;
+              }
+            default:
+              {
+                reader.skipType(tag & 7);
+                break;
+              }
+          }
+        }
+        return obj;
+      });
+    }
+    return _codec;
+  };
+  Identify.encode = obj => {
+    return encodeMessage(obj, Identify.codec());
+  };
+  Identify.decode = (buf, opts) => {
+    return decodeMessage(buf, Identify.codec(), opts);
+  };
+})(Identify$1 || (Identify$1 = {}));
+
+export { Identify$1 as Identify };