web-dc-api 0.0.58 → 0.0.60

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

@@ -0,0 +1,53 @@
+'use strict';
+
+var scalableCuckooFilter = require('../../../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 = scalableCuckooFilter.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);
+}
+
+exports.PeerFilter = PeerFilter;
+exports.peerFilter = peerFilter;

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

@@ -0,0 +1,79 @@
+'use strict';
+
+var util = require('./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 util.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 util.mapIterable(this.map.values(), val => {
+      return val.key;
+    });
+  }
+  values() {
+    return util.mapIterable(this.map.values(), val => val.value);
+  }
+  get size() {
+    return this.map.size;
+  }
+}
+
+exports.PeerMap = PeerMap;

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

@@ -0,0 +1,101 @@
+'use strict';
+
+var util = require('./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 util.mapIterable(this.set.entries(), val => {
+      const peerId = util.peerIdFromString(val[0]);
+      return [peerId, peerId];
+    });
+  }
+  forEach(predicate) {
+    this.set.forEach(str => {
+      const peerId = util.peerIdFromString(str);
+      predicate(peerId, peerId, this);
+    });
+  }
+  has(peer) {
+    return this.set.has(peer.toString());
+  }
+  values() {
+    return util.mapIterable(this.set.values(), val => {
+      return util.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();
+}
+
+exports.PeerSet = PeerSet;
+exports.peerSet = peerSet;

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

@@ -0,0 +1,39 @@
+'use strict';
+
+var peerId = require('@libp2p/peer-id');
+var base58 = require('../../../../multiformats/dist/src/bases/base58.js');
+var digest = require('../../../../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 = digest.decode(base58.base58btc.decode(`z${str}`));
+  return peerId.peerIdFromMultihash(multihash);
+}
+
+exports.mapIterable = mapIterable;
+exports.peerIdFromString = peerIdFromString;

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

@@ -0,0 +1,90 @@
+'use strict';
+
+var decode = require('../../../../../protons-runtime/dist/src/decode.js');
+var encode = require('../../../../../protons-runtime/dist/src/encode.js');
+require('../../../../../protons-runtime/dist/src/codec.js');
+var message = require('../../../../../protons-runtime/dist/src/codecs/message.js');
+var alloc = require('../../../../../uint8arrays/dist/src/alloc.js');
+require('../../../../../protons-runtime/dist/src/utils/float.js');
+require('../../../../../protons-runtime/dist/src/utils/longbits.js');
+require('../../../../../protons-runtime/dist/src/utils/writer.js');
+
+exports.Envelope = void 0;
+(function (Envelope) {
+  let _codec;
+  Envelope.codec = () => {
+    if (_codec == null) {
+      _codec = message.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.alloc(0),
+          payloadType: alloc.alloc(0),
+          payload: alloc.alloc(0),
+          signature: alloc.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 encode.encodeMessage(obj, Envelope.codec());
+  };
+  Envelope.decode = (buf, opts) => {
+    return decode.decodeMessage(buf, Envelope.codec(), opts);
+  };
+})(exports.Envelope || (exports.Envelope = {}));

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

@@ -0,0 +1,14 @@
+'use strict';
+
+/**
+ * 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';
+  }
+}
+
+exports.InvalidSignatureError = InvalidSignatureError;

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

@@ -0,0 +1,127 @@
+'use strict';
+
+var index = require('../../../../crypto/dist/src/keys/index.js');
+var index$1 = require('../../../../../uint8-varint/dist/src/index.js');
+var index$2 = require('../../../../../uint8arraylist/dist/src/index.js');
+var equals = require('../../../../../uint8arrays/dist/src/equals.js');
+var fromString = require('../../../../../uint8arrays/dist/src/from-string.js');
+var envelope = require('./envelope.js');
+var errors = require('./errors.js');
+
+class RecordEnvelope {
+  /**
+   * Unmarshal a serialized Envelope protobuf message
+   */
+  static createFromProtobuf = async data => {
+    const envelopeData = envelope.Envelope.decode(data);
+    const publicKey = index.publicKeyFromProtobuf(envelopeData.publicKey);
+    return new RecordEnvelope({
+      publicKey,
+      payloadType: envelopeData.payloadType,
+      payload: envelopeData.payload,
+      signature: envelopeData.signature
+    });
+  };
+  /**
+   * Seal marshals the given Record, places the marshaled bytes inside an Envelope
+   * and signs it with the given peerId's private key
+   */
+  static seal = async (record, privateKey) => {
+    if (privateKey == null) {
+      throw new Error('Missing private key');
+    }
+    const domain = record.domain;
+    const payloadType = record.codec;
+    const payload = record.marshal();
+    const signData = formatSignaturePayload(domain, payloadType, payload);
+    const signature = await privateKey.sign(signData.subarray());
+    return new RecordEnvelope({
+      publicKey: privateKey.publicKey,
+      payloadType,
+      payload,
+      signature
+    });
+  };
+  /**
+   * Open and certify a given marshaled envelope.
+   * Data is unmarshaled and the signature validated for the given domain.
+   */
+  static openAndCertify = async (data, domain) => {
+    const envelope = await RecordEnvelope.createFromProtobuf(data);
+    const valid = await envelope.validate(domain);
+    if (!valid) {
+      throw new errors.InvalidSignatureError('Envelope signature is not valid for the given domain');
+    }
+    return envelope;
+  };
+  publicKey;
+  payloadType;
+  payload;
+  signature;
+  marshaled;
+  /**
+   * The Envelope is responsible for keeping an arbitrary signed record
+   * by a libp2p peer.
+   */
+  constructor(init) {
+    const {
+      publicKey,
+      payloadType,
+      payload,
+      signature
+    } = init;
+    this.publicKey = publicKey;
+    this.payloadType = payloadType;
+    this.payload = payload;
+    this.signature = signature;
+  }
+  /**
+   * Marshal the envelope content
+   */
+  marshal() {
+    if (this.marshaled == null) {
+      this.marshaled = envelope.Envelope.encode({
+        publicKey: index.publicKeyToProtobuf(this.publicKey),
+        payloadType: this.payloadType,
+        payload: this.payload.subarray(),
+        signature: this.signature
+      });
+    }
+    return this.marshaled;
+  }
+  /**
+   * Verifies if the other Envelope is identical to this one
+   */
+  equals(other) {
+    if (other == null) {
+      return false;
+    }
+    return equals.equals(this.marshal(), other.marshal());
+  }
+  /**
+   * Validate envelope data signature for the given domain
+   */
+  async validate(domain) {
+    const signData = formatSignaturePayload(domain, this.payloadType, this.payload);
+    return this.publicKey.verify(signData.subarray(), this.signature);
+  }
+}
+/**
+ * Helper function that prepares a Uint8Array to sign or verify a signature
+ */
+const formatSignaturePayload = (domain, payloadType, payload) => {
+  // When signing, a peer will prepare a Uint8Array by concatenating the following:
+  // - The length of the domain separation string string in bytes
+  // - The domain separation string, encoded as UTF-8
+  // - The length of the payload_type field in bytes
+  // - The value of the payload_type field
+  // - The length of the payload field in bytes
+  // - The value of the payload field
+  const domainUint8Array = fromString.fromString(domain);
+  const domainLength = index$1.encode(domainUint8Array.byteLength);
+  const payloadTypeLength = index$1.encode(payloadType.length);
+  const payloadLength = index$1.encode(payload.length);
+  return new index$2.Uint8ArrayList(domainLength, domainUint8Array, payloadTypeLength, payloadType, payloadLength, payload);
+};
+
+exports.RecordEnvelope = RecordEnvelope;

package/dist/cjs/node_modules/@libp2p/peer-record/dist/src/peer-record/consts.js

@@ -0,0 +1,11 @@
+'use strict';
+
+// The domain string used for peer records contained in a Envelope.
+const ENVELOPE_DOMAIN_PEER_RECORD = 'libp2p-peer-record';
+// The type hint used to identify peer records in a Envelope.
+// Defined in https://github.com/multiformats/multicodec/blob/master/table.csv
+// with name "libp2p-peer-record"
+const ENVELOPE_PAYLOAD_TYPE_PEER_RECORD = Uint8Array.from([3, 1]);
+
+exports.ENVELOPE_DOMAIN_PEER_RECORD = ENVELOPE_DOMAIN_PEER_RECORD;
+exports.ENVELOPE_PAYLOAD_TYPE_PEER_RECORD = ENVELOPE_PAYLOAD_TYPE_PEER_RECORD;

package/dist/cjs/node_modules/@libp2p/peer-record/dist/src/peer-record/index.js

@@ -0,0 +1,85 @@
+'use strict';
+
+var peerId = require('@libp2p/peer-id');
+var arrayEquals = require('../../../../utils/dist/src/array-equals.js');
+var multiaddr = require('@multiformats/multiaddr');
+var digest = require('../../../../../multiformats/dist/src/hashes/digest.js');
+var consts = require('./consts.js');
+var peerRecord = require('./peer-record.js');
+
+/**
+ * The PeerRecord is used for distributing peer routing records across the network.
+ * It contains the peer's reachable listen addresses.
+ */
+class PeerRecord {
+  /**
+   * Unmarshal Peer Record Protobuf
+   */
+  static createFromProtobuf = buf => {
+    const peerRecord$1 = peerRecord.PeerRecord.decode(buf);
+    const peerId$1 = peerId.peerIdFromMultihash(digest.decode(peerRecord$1.peerId));
+    const multiaddrs = (peerRecord$1.addresses ?? []).map(a => multiaddr.multiaddr(a.multiaddr));
+    const seqNumber = peerRecord$1.seq;
+    return new PeerRecord({
+      peerId: peerId$1,
+      multiaddrs,
+      seqNumber
+    });
+  };
+  static DOMAIN = (() => consts.ENVELOPE_DOMAIN_PEER_RECORD)();
+  static CODEC = (() => consts.ENVELOPE_PAYLOAD_TYPE_PEER_RECORD)();
+  peerId;
+  multiaddrs;
+  seqNumber;
+  domain = (() => PeerRecord.DOMAIN)();
+  codec = (() => PeerRecord.CODEC)();
+  marshaled;
+  constructor(init) {
+    const {
+      peerId,
+      multiaddrs,
+      seqNumber
+    } = init;
+    this.peerId = peerId;
+    this.multiaddrs = multiaddrs ?? [];
+    this.seqNumber = seqNumber ?? BigInt(Date.now());
+  }
+  /**
+   * Marshal a record to be used in an envelope
+   */
+  marshal() {
+    if (this.marshaled == null) {
+      this.marshaled = peerRecord.PeerRecord.encode({
+        peerId: this.peerId.toMultihash().bytes,
+        seq: BigInt(this.seqNumber),
+        addresses: this.multiaddrs.map(m => ({
+          multiaddr: m.bytes
+        }))
+      });
+    }
+    return this.marshaled;
+  }
+  /**
+   * Returns true if `this` record equals the `other`
+   */
+  equals(other) {
+    if (!(other instanceof PeerRecord)) {
+      return false;
+    }
+    // Validate PeerId
+    if (!this.peerId.equals(other.peerId)) {
+      return false;
+    }
+    // Validate seqNumber
+    if (this.seqNumber !== other.seqNumber) {
+      return false;
+    }
+    // Validate multiaddrs
+    if (!arrayEquals.arrayEquals(this.multiaddrs, other.multiaddrs)) {
+      return false;
+    }
+    return true;
+  }
+}
+
+exports.PeerRecord = PeerRecord;