web-dc-api 0.0.58 → 0.0.60

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

@@ -0,0 +1,214 @@
+import { publicKeyFromProtobuf } from '../../../crypto/dist/src/keys/index.js';
+import { InvalidMessageError } from '@libp2p/interface';
+import { peerIdFromPublicKey, peerIdFromCID } from '@libp2p/peer-id';
+import { multiaddr } from '@multiformats/multiaddr';
+import { fromString } from '../../../../uint8arrays/dist/src/from-string.js';
+import { MAX_PUSH_CONCURRENCY, MAX_IDENTIFY_MESSAGE_SIZE, IDENTIFY_PROTOCOL_VERSION } from './consts.js';
+import { RecordEnvelope } from '../../../peer-record/dist/src/envelope/index.js';
+import { PeerRecord } from '../../../peer-record/dist/src/peer-record/index.js';
+
+const defaultValues = {
+  protocolPrefix: 'ipfs',
+  timeout: 5000,
+  maxInboundStreams: 1,
+  maxOutboundStreams: 1,
+  maxObservedAddresses: 10,
+  maxMessageSize: MAX_IDENTIFY_MESSAGE_SIZE,
+  runOnConnectionOpen: true,
+  runOnSelfUpdate: true,
+  runOnLimitedConnection: true,
+  concurrency: MAX_PUSH_CONCURRENCY
+};
+/**
+ * Takes the `addr` and converts it to a Multiaddr if possible
+ */
+function getCleanMultiaddr(addr) {
+  if (addr != null && addr.length > 0) {
+    try {
+      return multiaddr(addr);
+    } catch {}
+  }
+}
+function getAgentVersion(nodeInfo, agentVersion) {
+  if (agentVersion != null) {
+    return agentVersion;
+  }
+  return nodeInfo.userAgent;
+}
+async function consumeIdentifyMessage(peerStore, events, log, connection, message) {
+  log('received identify from %p', connection.remotePeer);
+  if (message == null) {
+    throw new InvalidMessageError('message was null or undefined');
+  }
+  const peer = {};
+  if (message.listenAddrs.length > 0) {
+    peer.addresses = message.listenAddrs.map(buf => ({
+      isCertified: false,
+      multiaddr: multiaddr(buf)
+    }));
+  }
+  if (message.protocols.length > 0) {
+    peer.protocols = message.protocols;
+  }
+  if (message.publicKey != null) {
+    const publicKey = publicKeyFromProtobuf(message.publicKey);
+    const peerId = peerIdFromPublicKey(publicKey);
+    if (!peerId.equals(connection.remotePeer)) {
+      throw new InvalidMessageError('public key did not match remote PeerId');
+    }
+    peer.publicKey = publicKey;
+  }
+  let output;
+  // if the peer record has been sent, prefer the addresses in the record as they are signed by the remote peer
+  if (message.signedPeerRecord != null) {
+    log.trace('received signedPeerRecord from %p', connection.remotePeer);
+    let peerRecordEnvelope = message.signedPeerRecord;
+    const envelope = await RecordEnvelope.openAndCertify(peerRecordEnvelope, PeerRecord.DOMAIN);
+    let peerRecord = PeerRecord.createFromProtobuf(envelope.payload);
+    const envelopePeer = peerIdFromCID(envelope.publicKey.toCID());
+    // Verify peerId
+    if (!peerRecord.peerId.equals(envelopePeer)) {
+      throw new InvalidMessageError('signing key does not match PeerId in the PeerRecord');
+    }
+    // Make sure remote peer is the one sending the record
+    if (!connection.remotePeer.equals(peerRecord.peerId)) {
+      throw new InvalidMessageError('signing key does not match remote PeerId');
+    }
+    let existingPeer;
+    try {
+      existingPeer = await peerStore.get(peerRecord.peerId);
+    } catch (err) {
+      if (err.name !== 'NotFoundError') {
+        throw err;
+      }
+    }
+    if (existingPeer != null) {
+      // don't lose any existing metadata
+      peer.metadata = existingPeer.metadata;
+      // if we have previously received a signed record for this peer, compare it to the incoming one
+      if (existingPeer.peerRecordEnvelope != null) {
+        const storedEnvelope = await RecordEnvelope.createFromProtobuf(existingPeer.peerRecordEnvelope);
+        const storedRecord = PeerRecord.createFromProtobuf(storedEnvelope.payload);
+        // ensure seq is greater than, or equal to, the last received
+        if (storedRecord.seqNumber >= peerRecord.seqNumber) {
+          log('sequence number was lower or equal to existing sequence number - stored: %d received: %d', storedRecord.seqNumber, peerRecord.seqNumber);
+          peerRecord = storedRecord;
+          peerRecordEnvelope = existingPeer.peerRecordEnvelope;
+        }
+      }
+    }
+    // store the signed record for next time
+    peer.peerRecordEnvelope = peerRecordEnvelope;
+    // override the stored addresses with the signed multiaddrs
+    peer.addresses = peerRecord.multiaddrs.map(multiaddr => ({
+      isCertified: true,
+      multiaddr
+    }));
+    output = {
+      seq: peerRecord.seqNumber,
+      addresses: peerRecord.multiaddrs
+    };
+  } else {
+    log('%p did not send a signed peer record', connection.remotePeer);
+  }
+  log.trace('patching %p with', connection.remotePeer, peer);
+  await peerStore.patch(connection.remotePeer, peer);
+  if (message.agentVersion != null || message.protocolVersion != null) {
+    const metadata = {};
+    if (message.agentVersion != null) {
+      metadata.AgentVersion = fromString(message.agentVersion);
+    }
+    if (message.protocolVersion != null) {
+      metadata.ProtocolVersion = fromString(message.protocolVersion);
+    }
+    log.trace('merging %p metadata', connection.remotePeer, metadata);
+    await peerStore.merge(connection.remotePeer, {
+      metadata
+    });
+  }
+  const result = {
+    peerId: connection.remotePeer,
+    protocolVersion: message.protocolVersion,
+    agentVersion: message.agentVersion,
+    publicKey: message.publicKey,
+    listenAddrs: message.listenAddrs.map(buf => multiaddr(buf)),
+    observedAddr: message.observedAddr == null ? undefined : multiaddr(message.observedAddr),
+    protocols: message.protocols,
+    signedPeerRecord: output,
+    connection
+  };
+  events.safeDispatchEvent('peer:identify', {
+    detail: result
+  });
+  return result;
+}
+class AbstractIdentify {
+  host;
+  protocol;
+  started;
+  timeout;
+  peerId;
+  privateKey;
+  peerStore;
+  registrar;
+  addressManager;
+  maxInboundStreams;
+  maxOutboundStreams;
+  maxMessageSize;
+  maxObservedAddresses;
+  events;
+  runOnLimitedConnection;
+  log;
+  constructor(components, init) {
+    this.protocol = init.protocol;
+    this.started = false;
+    this.peerId = components.peerId;
+    this.privateKey = components.privateKey;
+    this.peerStore = components.peerStore;
+    this.registrar = components.registrar;
+    this.addressManager = components.addressManager;
+    this.events = components.events;
+    this.log = init.log;
+    this.timeout = init.timeout ?? defaultValues.timeout;
+    this.maxInboundStreams = init.maxInboundStreams ?? defaultValues.maxInboundStreams;
+    this.maxOutboundStreams = init.maxOutboundStreams ?? defaultValues.maxOutboundStreams;
+    this.maxMessageSize = init.maxMessageSize ?? defaultValues.maxMessageSize;
+    this.maxObservedAddresses = init.maxObservedAddresses ?? defaultValues.maxObservedAddresses;
+    this.runOnLimitedConnection = init.runOnLimitedConnection ?? defaultValues.runOnLimitedConnection;
+    // Store self host metadata
+    this.host = {
+      protocolVersion: `${init.protocolPrefix ?? defaultValues.protocolPrefix}/${IDENTIFY_PROTOCOL_VERSION}`,
+      agentVersion: getAgentVersion(components.nodeInfo, init.agentVersion)
+    };
+  }
+  isStarted() {
+    return this.started;
+  }
+  async start() {
+    if (this.started) {
+      return;
+    }
+    await this.peerStore.merge(this.peerId, {
+      metadata: {
+        AgentVersion: fromString(this.host.agentVersion),
+        ProtocolVersion: fromString(this.host.protocolVersion)
+      }
+    });
+    await this.registrar.handle(this.protocol, data => {
+      void this.handleProtocol(data).catch(err => {
+        this.log.error(err);
+      });
+    }, {
+      maxInboundStreams: this.maxInboundStreams,
+      maxOutboundStreams: this.maxOutboundStreams,
+      runOnLimitedConnection: this.runOnLimitedConnection
+    });
+    this.started = true;
+  }
+  async stop() {
+    await this.registrar.unhandle(this.protocol);
+    this.started = false;
+  }
+}
+
+export { AbstractIdentify, consumeIdentifyMessage, defaultValues, getAgentVersion, getCleanMultiaddr };

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

@@ -0,0 +1,118 @@
+import { base32 } from '../../../../multiformats/dist/src/bases/base32.js';
+import { base58btc } from '../../../../multiformats/dist/src/bases/base58.js';
+import { base64 } from '../../../../multiformats/dist/src/bases/base64.js';
+import weald from '../../../../weald/dist/src/browser.js';
+
+/**
+ * @packageDocumentation
+ *
+ * A logger for libp2p based on [weald](https://www.npmjs.com/package/weald), a TypeScript port of the venerable [debug](https://www.npmjs.com/package/debug) module.
+ *
+ * @example
+ *
+ * ```TypeScript
+ * import { logger } from '@libp2p/logger'
+ *
+ * const log = logger('libp2p:my:component:name')
+ *
+ * try {
+ *   // an operation
+ *   log('something happened: %s', 'it was ok')
+ * } catch (err) {
+ *   log.error('something bad happened: %o', err)
+ * }
+ *
+ * log('with this peer: %p', {})
+ * log('and this base58btc: %b', Uint8Array.from([0, 1, 2, 3]))
+ * log('and this base32: %t', Uint8Array.from([4, 5, 6, 7]))
+ * ```
+ *
+ * ```console
+ * $ DEBUG=libp2p:* node index.js
+ * something happened: it was ok
+ * something bad happened: <stack trace>
+ * with this peer: 12D3Foo
+ * with this base58btc: Qmfoo
+ * with this base32: bafyfoo
+ * ```
+ */
+// Add a formatter for converting to a base58 string
+weald.formatters.b = v => {
+  return v == null ? 'undefined' : base58btc.baseEncode(v);
+};
+// Add a formatter for converting to a base32 string
+weald.formatters.t = v => {
+  return v == null ? 'undefined' : base32.baseEncode(v);
+};
+// Add a formatter for converting to a base64 string
+weald.formatters.m = v => {
+  return v == null ? 'undefined' : base64.baseEncode(v);
+};
+// Add a formatter for stringifying peer ids
+weald.formatters.p = v => {
+  return v == null ? 'undefined' : v.toString();
+};
+// Add a formatter for stringifying CIDs
+weald.formatters.c = v => {
+  return v == null ? 'undefined' : v.toString();
+};
+// Add a formatter for stringifying Datastore keys
+weald.formatters.k = v => {
+  return v == null ? 'undefined' : v.toString();
+};
+// Add a formatter for stringifying Multiaddrs
+weald.formatters.a = v => {
+  return v == null ? 'undefined' : v.toString();
+};
+// Add a formatter for stringifying Errors
+weald.formatters.e = v => {
+  return v == null ? 'undefined' : notEmpty(v.stack) ?? notEmpty(v.message) ?? v.toString();
+};
+function createDisabledLogger(namespace) {
+  const logger = () => {};
+  logger.enabled = false;
+  logger.color = '';
+  logger.diff = 0;
+  logger.log = () => {};
+  logger.namespace = namespace;
+  logger.destroy = () => true;
+  logger.extend = () => logger;
+  return logger;
+}
+/**
+ * Creates a logger for the passed component name.
+ *
+ * @example
+ *
+ * ```TypeScript
+ * import { logger } from '@libp2p/logger'
+ *
+ * const log = logger('my-component')
+ * log.info('hello world')
+ * // logs "my-component hello world"
+ * ```
+ */
+function logger(name) {
+  // trace logging is a no-op by default
+  let trace = createDisabledLogger(`${name}:trace`);
+  // look at all the debug names and see if trace logging has explicitly been enabled
+  if (weald.enabled(`${name}:trace`) && weald.names.map(r => r.toString()).find(n => n.includes(':trace')) != null) {
+    trace = weald(`${name}:trace`);
+  }
+  return Object.assign(weald(name), {
+    error: weald(`${name}:error`),
+    trace
+  });
+}
+function notEmpty(str) {
+  if (str == null) {
+    return;
+  }
+  str = str.trim();
+  if (str.length === 0) {
+    return;
+  }
+  return str;
+}
+
+export { logger };

package/dist/esm/node_modules/@libp2p/peer-collections/dist/src/filter.js

@@ -0,0 +1,50 @@
+import { createScalableCuckooFilter } from '../../../utils/dist/src/filters/scalable-cuckoo-filter.js';
+
+/**
+ * Uses a Cuckoo filter to implement a mechanism for deduplicating PeerIds in a
+ * way that uses a smaller amount of memory than a PeerSet.
+ */
+class PeerFilter {
+  filter;
+  constructor(size, errorRate) {
+    this.filter = createScalableCuckooFilter(size, errorRate);
+  }
+  has(peerId) {
+    return this.filter.has(peerId.toMultihash().bytes);
+  }
+  add(peerId) {
+    this.filter.add(peerId.toMultihash().bytes);
+  }
+  remove(peerId) {
+    this.filter.remove?.(peerId.toMultihash().bytes);
+  }
+}
+/**
+ * Create and return a PeerFilter. This can be used by topologies to prevent
+ * them receiving duplicate notifications for a peer that connects repeatedly.
+ *
+ * @example
+ *
+ * ```TypeScript
+ * import { peerFilter } from '@libp2p/peer-collections'
+ * import type { Registrar } from '@libp2p/interface-internal'
+ *
+ * const registrar: Registrar
+ *
+ * registrar.register('/my/protocol/1.0.0', {
+ *   filter: peerFilter(),
+ *   onConnect: (peerId) => {
+ *     // will only be invoked for a given peerId once
+ *   }
+ * })
+ * ```
+ *
+ * @param size - The maximum number of peers expected to be added to the filter
+ * @param errorRate - The acceptable error rate
+ */
+function peerFilter(size) {
+  let errorRate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.001;
+  return new PeerFilter(size, errorRate);
+}
+
+export { PeerFilter, peerFilter };

package/dist/esm/node_modules/@libp2p/peer-collections/dist/src/map.js

@@ -0,0 +1,77 @@
+import { mapIterable } from './util.js';
+
+/**
+ * We can't use PeerIds as map keys because map keys are
+ * compared using same-value-zero equality, so this is just
+ * a map that stringifies the PeerIds before storing them.
+ *
+ * PeerIds cache stringified versions of themselves so this
+ * should be a cheap operation.
+ *
+ * @example
+ *
+ * ```TypeScript
+ * import { peerMap } from '@libp2p/peer-collections'
+ *
+ * const map = peerMap<string>()
+ * map.set(peerId, 'value')
+ * ```
+ */
+class PeerMap {
+  map;
+  constructor(map) {
+    this.map = new Map();
+    if (map != null) {
+      for (const [key, value] of map.entries()) {
+        this.map.set(key.toString(), {
+          key,
+          value
+        });
+      }
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  clear() {
+    this.map.clear();
+  }
+  delete(peer) {
+    return this.map.delete(peer.toString());
+  }
+  entries() {
+    return mapIterable(this.map.entries(), val => {
+      return [val[1].key, val[1].value];
+    });
+  }
+  forEach(fn) {
+    this.map.forEach((value, key) => {
+      fn(value.value, value.key, this);
+    });
+  }
+  get(peer) {
+    return this.map.get(peer.toString())?.value;
+  }
+  has(peer) {
+    return this.map.has(peer.toString());
+  }
+  set(peer, value) {
+    this.map.set(peer.toString(), {
+      key: peer,
+      value
+    });
+  }
+  keys() {
+    return mapIterable(this.map.values(), val => {
+      return val.key;
+    });
+  }
+  values() {
+    return mapIterable(this.map.values(), val => val.value);
+  }
+  get size() {
+    return this.map.size;
+  }
+}
+
+export { PeerMap };

package/dist/esm/node_modules/@libp2p/peer-collections/dist/src/set.js

@@ -0,0 +1,98 @@
+import { mapIterable, peerIdFromString } from './util.js';
+
+/**
+ * We can't use PeerIds as set entries because set entries are
+ * compared using same-value-zero equality, so this is just
+ * a map that stringifies the PeerIds before storing them.
+ *
+ * PeerIds cache stringified versions of themselves so this
+ * should be a cheap operation.
+ *
+ * @example
+ *
+ * ```TypeScript
+ * import { peerSet } from '@libp2p/peer-collections'
+ *
+ * const set = peerSet()
+ * set.add(peerId)
+ * ```
+ */
+class PeerSet {
+  set;
+  constructor(set) {
+    this.set = new Set();
+    if (set != null) {
+      for (const key of set) {
+        this.set.add(key.toString());
+      }
+    }
+  }
+  get size() {
+    return this.set.size;
+  }
+  [Symbol.iterator]() {
+    return this.values();
+  }
+  add(peer) {
+    this.set.add(peer.toString());
+  }
+  clear() {
+    this.set.clear();
+  }
+  delete(peer) {
+    this.set.delete(peer.toString());
+  }
+  entries() {
+    return mapIterable(this.set.entries(), val => {
+      const peerId = peerIdFromString(val[0]);
+      return [peerId, peerId];
+    });
+  }
+  forEach(predicate) {
+    this.set.forEach(str => {
+      const peerId = peerIdFromString(str);
+      predicate(peerId, peerId, this);
+    });
+  }
+  has(peer) {
+    return this.set.has(peer.toString());
+  }
+  values() {
+    return mapIterable(this.set.values(), val => {
+      return peerIdFromString(val);
+    });
+  }
+  intersection(other) {
+    const output = new PeerSet();
+    for (const peerId of other) {
+      if (this.has(peerId)) {
+        output.add(peerId);
+      }
+    }
+    return output;
+  }
+  difference(other) {
+    const output = new PeerSet();
+    for (const peerId of this) {
+      if (!other.has(peerId)) {
+        output.add(peerId);
+      }
+    }
+    return output;
+  }
+  union(other) {
+    const output = new PeerSet();
+    for (const peerId of other) {
+      output.add(peerId);
+    }
+    for (const peerId of this) {
+      output.add(peerId);
+    }
+    return output;
+  }
+}
+function peerSet() {
+  return new PeerSet();
+}
+
+export { PeerSet, peerSet };

package/dist/esm/node_modules/@libp2p/peer-collections/dist/src/util.js

@@ -0,0 +1,36 @@
+import { peerIdFromMultihash } from '@libp2p/peer-id';
+import { base58btc } from '../../../../multiformats/dist/src/bases/base58.js';
+import { decode } from '../../../../multiformats/dist/src/hashes/digest.js';
+
+/**
+ * Calls the passed map function on every entry of the passed iterable iterator
+ */
+function mapIterable(iter, map) {
+  const iterator = {
+    [Symbol.iterator]: () => {
+      return iterator;
+    },
+    next: () => {
+      const next = iter.next();
+      const val = next.value;
+      if (next.done === true || val == null) {
+        const result = {
+          done: true,
+          value: undefined
+        };
+        return result;
+      }
+      return {
+        done: false,
+        value: map(val)
+      };
+    }
+  };
+  return iterator;
+}
+function peerIdFromString(str) {
+  const multihash = decode(base58btc.decode(`z${str}`));
+  return peerIdFromMultihash(multihash);
+}
+
+export { mapIterable, peerIdFromString };

package/dist/esm/node_modules/@libp2p/peer-record/dist/src/envelope/envelope.js

@@ -0,0 +1,90 @@
+import { decodeMessage } from '../../../../../protons-runtime/dist/src/decode.js';
+import { encodeMessage } from '../../../../../protons-runtime/dist/src/encode.js';
+import '../../../../../protons-runtime/dist/src/codec.js';
+import { message } from '../../../../../protons-runtime/dist/src/codecs/message.js';
+import { alloc } from '../../../../../uint8arrays/dist/src/alloc.js';
+import '../../../../../protons-runtime/dist/src/utils/float.js';
+import '../../../../../protons-runtime/dist/src/utils/longbits.js';
+import '../../../../../protons-runtime/dist/src/utils/writer.js';
+
+var Envelope;
+(function (Envelope) {
+  let _codec;
+  Envelope.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.publicKey != null && obj.publicKey.byteLength > 0) {
+          w.uint32(10);
+          w.bytes(obj.publicKey);
+        }
+        if (obj.payloadType != null && obj.payloadType.byteLength > 0) {
+          w.uint32(18);
+          w.bytes(obj.payloadType);
+        }
+        if (obj.payload != null && obj.payload.byteLength > 0) {
+          w.uint32(26);
+          w.bytes(obj.payload);
+        }
+        if (obj.signature != null && obj.signature.byteLength > 0) {
+          w.uint32(42);
+          w.bytes(obj.signature);
+        }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim();
+        }
+      }, function (reader, length) {
+        const obj = {
+          publicKey: alloc(0),
+          payloadType: alloc(0),
+          payload: alloc(0),
+          signature: alloc(0)
+        };
+        const end = length == null ? reader.len : reader.pos + length;
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1:
+              {
+                obj.publicKey = reader.bytes();
+                break;
+              }
+            case 2:
+              {
+                obj.payloadType = reader.bytes();
+                break;
+              }
+            case 3:
+              {
+                obj.payload = reader.bytes();
+                break;
+              }
+            case 5:
+              {
+                obj.signature = reader.bytes();
+                break;
+              }
+            default:
+              {
+                reader.skipType(tag & 7);
+                break;
+              }
+          }
+        }
+        return obj;
+      });
+    }
+    return _codec;
+  };
+  Envelope.encode = obj => {
+    return encodeMessage(obj, Envelope.codec());
+  };
+  Envelope.decode = (buf, opts) => {
+    return decodeMessage(buf, Envelope.codec(), opts);
+  };
+})(Envelope || (Envelope = {}));
+
+export { Envelope };

package/dist/esm/node_modules/@libp2p/peer-record/dist/src/envelope/errors.js

@@ -0,0 +1,12 @@
+/**
+ * The key in the record is not valid for the domain
+ */
+class InvalidSignatureError extends Error {
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Invalid signature';
+    super(message);
+    this.name = 'InvalidSignatureError';
+  }
+}
+
+export { InvalidSignatureError };