web-dc-api 0.0.60 → 0.0.62

package/dist/cjs/node_modules/@libp2p/peer-store/dist/src/pb/peer.js

@@ -0,0 +1,393 @@
+'use strict';
+
+var index = require('../../../../../protons-runtime/dist/src/index.js');
+var alloc = require('../../../../../uint8arrays/dist/src/alloc.js');
+var message = require('../../../../../protons-runtime/dist/src/codecs/message.js');
+var encode = require('../../../../../protons-runtime/dist/src/encode.js');
+var decode = require('../../../../../protons-runtime/dist/src/decode.js');
+
+/* eslint-disable complexity */
+exports.Peer = void 0;
+(function (Peer) {
+  (function (Peer$metadataEntry) {
+    let _codec;
+    Peer$metadataEntry.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.key != null && obj.key !== '') {
+            w.uint32(10);
+            w.string(obj.key);
+          }
+          if (obj.value != null && obj.value.byteLength > 0) {
+            w.uint32(18);
+            w.bytes(obj.value);
+          }
+          if (opts.lengthDelimited !== false) {
+            w.ldelim();
+          }
+        }, function (reader, length) {
+          const obj = {
+            key: '',
+            value: 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.key = reader.string();
+                  break;
+                }
+              case 2:
+                {
+                  obj.value = reader.bytes();
+                  break;
+                }
+              default:
+                {
+                  reader.skipType(tag & 7);
+                  break;
+                }
+            }
+          }
+          return obj;
+        });
+      }
+      return _codec;
+    };
+    Peer$metadataEntry.encode = obj => {
+      return encode.encodeMessage(obj, Peer$metadataEntry.codec());
+    };
+    Peer$metadataEntry.decode = (buf, opts) => {
+      return decode.decodeMessage(buf, Peer$metadataEntry.codec(), opts);
+    };
+  })(Peer.Peer$metadataEntry || (Peer.Peer$metadataEntry = {}));
+  (function (Peer$tagsEntry) {
+    let _codec;
+    Peer$tagsEntry.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.key != null && obj.key !== '') {
+            w.uint32(10);
+            w.string(obj.key);
+          }
+          if (obj.value != null) {
+            w.uint32(18);
+            exports.Tag.codec().encode(obj.value, w);
+          }
+          if (opts.lengthDelimited !== false) {
+            w.ldelim();
+          }
+        }, function (reader, length) {
+          let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+          const obj = {
+            key: ''
+          };
+          const end = length == null ? reader.len : reader.pos + length;
+          while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+              case 1:
+                {
+                  obj.key = reader.string();
+                  break;
+                }
+              case 2:
+                {
+                  obj.value = exports.Tag.codec().decode(reader, reader.uint32(), {
+                    limits: opts.limits?.value
+                  });
+                  break;
+                }
+              default:
+                {
+                  reader.skipType(tag & 7);
+                  break;
+                }
+            }
+          }
+          return obj;
+        });
+      }
+      return _codec;
+    };
+    Peer$tagsEntry.encode = obj => {
+      return encode.encodeMessage(obj, Peer$tagsEntry.codec());
+    };
+    Peer$tagsEntry.decode = (buf, opts) => {
+      return decode.decodeMessage(buf, Peer$tagsEntry.codec(), opts);
+    };
+  })(Peer.Peer$tagsEntry || (Peer.Peer$tagsEntry = {}));
+  let _codec;
+  Peer.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.addresses != null) {
+          for (const value of obj.addresses) {
+            w.uint32(10);
+            exports.Address.codec().encode(value, w);
+          }
+        }
+        if (obj.protocols != null) {
+          for (const value of obj.protocols) {
+            w.uint32(18);
+            w.string(value);
+          }
+        }
+        if (obj.publicKey != null) {
+          w.uint32(34);
+          w.bytes(obj.publicKey);
+        }
+        if (obj.peerRecordEnvelope != null) {
+          w.uint32(42);
+          w.bytes(obj.peerRecordEnvelope);
+        }
+        if (obj.metadata != null && obj.metadata.size !== 0) {
+          for (const [key, value] of obj.metadata.entries()) {
+            w.uint32(50);
+            Peer.Peer$metadataEntry.codec().encode({
+              key,
+              value
+            }, w);
+          }
+        }
+        if (obj.tags != null && obj.tags.size !== 0) {
+          for (const [key, value] of obj.tags.entries()) {
+            w.uint32(58);
+            Peer.Peer$tagsEntry.codec().encode({
+              key,
+              value
+            }, w);
+          }
+        }
+        if (obj.updated != null) {
+          w.uint32(64);
+          w.uint64Number(obj.updated);
+        }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim();
+        }
+      }, function (reader, length) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        const obj = {
+          addresses: [],
+          protocols: [],
+          metadata: new Map(),
+          tags: new Map()
+        };
+        const end = length == null ? reader.len : reader.pos + length;
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1:
+              {
+                if (opts.limits?.addresses != null && obj.addresses.length === opts.limits.addresses) {
+                  throw new index.MaxLengthError('Decode error - map field "addresses" had too many elements');
+                }
+                obj.addresses.push(exports.Address.codec().decode(reader, reader.uint32(), {
+                  limits: opts.limits?.addresses$
+                }));
+                break;
+              }
+            case 2:
+              {
+                if (opts.limits?.protocols != null && obj.protocols.length === opts.limits.protocols) {
+                  throw new index.MaxLengthError('Decode error - map field "protocols" had too many elements');
+                }
+                obj.protocols.push(reader.string());
+                break;
+              }
+            case 4:
+              {
+                obj.publicKey = reader.bytes();
+                break;
+              }
+            case 5:
+              {
+                obj.peerRecordEnvelope = reader.bytes();
+                break;
+              }
+            case 6:
+              {
+                if (opts.limits?.metadata != null && obj.metadata.size === opts.limits.metadata) {
+                  throw new index.MaxSizeError('Decode error - map field "metadata" had too many elements');
+                }
+                const entry = Peer.Peer$metadataEntry.codec().decode(reader, reader.uint32());
+                obj.metadata.set(entry.key, entry.value);
+                break;
+              }
+            case 7:
+              {
+                if (opts.limits?.tags != null && obj.tags.size === opts.limits.tags) {
+                  throw new index.MaxSizeError('Decode error - map field "tags" had too many elements');
+                }
+                const entry = Peer.Peer$tagsEntry.codec().decode(reader, reader.uint32(), {
+                  limits: {
+                    value: opts.limits?.tags$value
+                  }
+                });
+                obj.tags.set(entry.key, entry.value);
+                break;
+              }
+            case 8:
+              {
+                obj.updated = reader.uint64Number();
+                break;
+              }
+            default:
+              {
+                reader.skipType(tag & 7);
+                break;
+              }
+          }
+        }
+        return obj;
+      });
+    }
+    return _codec;
+  };
+  Peer.encode = obj => {
+    return encode.encodeMessage(obj, Peer.codec());
+  };
+  Peer.decode = (buf, opts) => {
+    return decode.decodeMessage(buf, Peer.codec(), opts);
+  };
+})(exports.Peer || (exports.Peer = {}));
+exports.Address = void 0;
+(function (Address) {
+  let _codec;
+  Address.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.multiaddr != null && obj.multiaddr.byteLength > 0) {
+          w.uint32(10);
+          w.bytes(obj.multiaddr);
+        }
+        if (obj.isCertified != null) {
+          w.uint32(16);
+          w.bool(obj.isCertified);
+        }
+        if (obj.observed != null) {
+          w.uint32(24);
+          w.uint64Number(obj.observed);
+        }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim();
+        }
+      }, function (reader, length) {
+        const obj = {
+          multiaddr: 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.multiaddr = reader.bytes();
+                break;
+              }
+            case 2:
+              {
+                obj.isCertified = reader.bool();
+                break;
+              }
+            case 3:
+              {
+                obj.observed = reader.uint64Number();
+                break;
+              }
+            default:
+              {
+                reader.skipType(tag & 7);
+                break;
+              }
+          }
+        }
+        return obj;
+      });
+    }
+    return _codec;
+  };
+  Address.encode = obj => {
+    return encode.encodeMessage(obj, Address.codec());
+  };
+  Address.decode = (buf, opts) => {
+    return decode.decodeMessage(buf, Address.codec(), opts);
+  };
+})(exports.Address || (exports.Address = {}));
+exports.Tag = void 0;
+(function (Tag) {
+  let _codec;
+  Tag.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.value != null && obj.value !== 0) {
+          w.uint32(8);
+          w.uint32(obj.value);
+        }
+        if (obj.expiry != null) {
+          w.uint32(16);
+          w.uint64(obj.expiry);
+        }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim();
+        }
+      }, function (reader, length) {
+        const obj = {
+          value: 0
+        };
+        const end = length == null ? reader.len : reader.pos + length;
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1:
+              {
+                obj.value = reader.uint32();
+                break;
+              }
+            case 2:
+              {
+                obj.expiry = reader.uint64();
+                break;
+              }
+            default:
+              {
+                reader.skipType(tag & 7);
+                break;
+              }
+          }
+        }
+        return obj;
+      });
+    }
+    return _codec;
+  };
+  Tag.encode = obj => {
+    return encode.encodeMessage(obj, Tag.codec());
+  };
+  Tag.decode = (buf, opts) => {
+    return decode.decodeMessage(buf, Tag.codec(), opts);
+  };
+})(exports.Tag || (exports.Tag = {}));

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

@@ -0,0 +1,177 @@
+'use strict';
+
+var index$1 = require('../../../peer-id/dist/src/index.js');
+var index = require('../../../../mortice/dist/src/index.js');
+var base32 = require('../../../../multiformats/dist/src/bases/base32.js');
+var cid = require('../../../../multiformats/dist/src/cid.js');
+var constants = require('./constants.js');
+var peer = require('./pb/peer.js');
+var bytesToPeer = require('./utils/bytes-to-peer.js');
+var peerEquals = require('./utils/peer-equals.js');
+var peerIdToDatastoreKey = require('./utils/peer-id-to-datastore-key.js');
+var toPeerPb = require('./utils/to-peer-pb.js');
+var errors = require('../../../interface/dist/src/errors.js');
+
+function keyToPeerId(key) {
+  // /peers/${peer-id-as-libp2p-key-cid-string-in-base-32}
+  const base32Str = key.toString().split('/')[2];
+  const buf = cid.CID.parse(base32Str, base32.base32);
+  return index$1.peerIdFromCID(buf);
+}
+function decodePeer(key, value, maxAddressAge) {
+  const peerId = keyToPeerId(key);
+  return bytesToPeer.bytesToPeer(peerId, value, maxAddressAge);
+}
+function mapQuery(query, maxAddressAge) {
+  return {
+    prefix: peerIdToDatastoreKey.NAMESPACE_COMMON,
+    filters: (query.filters ?? []).map(fn => _ref => {
+      let {
+        key,
+        value
+      } = _ref;
+      return fn(decodePeer(key, value, maxAddressAge));
+    }),
+    orders: (query.orders ?? []).map(fn => (a, b) => {
+      return fn(decodePeer(a.key, a.value, maxAddressAge), decodePeer(b.key, b.value, maxAddressAge));
+    })
+  };
+}
+class PersistentStore {
+  peerId;
+  datastore;
+  lock;
+  addressFilter;
+  log;
+  maxAddressAge;
+  maxPeerAge;
+  constructor(components) {
+    let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    this.log = components.logger.forComponent('libp2p:peer-store');
+    this.peerId = components.peerId;
+    this.datastore = components.datastore;
+    this.addressFilter = init.addressFilter;
+    this.lock = index.default({
+      name: 'peer-store',
+      singleProcess: true
+    });
+    this.maxAddressAge = init.maxAddressAge ?? constants.MAX_ADDRESS_AGE;
+    this.maxPeerAge = init.maxPeerAge ?? constants.MAX_PEER_AGE;
+  }
+  async has(peerId) {
+    try {
+      await this.load(peerId);
+      return true;
+    } catch (err) {
+      if (err.name !== 'NotFoundError') {
+        throw err;
+      }
+    }
+    return false;
+  }
+  async delete(peerId) {
+    if (this.peerId.equals(peerId)) {
+      return;
+    }
+    await this.datastore.delete(peerIdToDatastoreKey.peerIdToDatastoreKey(peerId));
+  }
+  async load(peerId) {
+    const key = peerIdToDatastoreKey.peerIdToDatastoreKey(peerId);
+    const buf = await this.datastore.get(key);
+    const peer$1 = peer.Peer.decode(buf);
+    if (this.#peerIsExpired(peerId, peer$1)) {
+      await this.datastore.delete(key);
+      throw new errors.NotFoundError();
+    }
+    return bytesToPeer.pbToPeer(peerId, peer$1, this.peerId.equals(peerId) ? Infinity : this.maxAddressAge);
+  }
+  async save(peerId, data) {
+    const existingPeer = await this.#findExistingPeer(peerId);
+    const peerPb = await toPeerPb.toPeerPB(peerId, data, 'patch', {
+      addressFilter: this.addressFilter
+    });
+    return this.#saveIfDifferent(peerId, peerPb, existingPeer);
+  }
+  async patch(peerId, data) {
+    const existingPeer = await this.#findExistingPeer(peerId);
+    const peerPb = await toPeerPb.toPeerPB(peerId, data, 'patch', {
+      addressFilter: this.addressFilter,
+      existingPeer
+    });
+    return this.#saveIfDifferent(peerId, peerPb, existingPeer);
+  }
+  async merge(peerId, data) {
+    const existingPeer = await this.#findExistingPeer(peerId);
+    const peerPb = await toPeerPb.toPeerPB(peerId, data, 'merge', {
+      addressFilter: this.addressFilter,
+      existingPeer
+    });
+    return this.#saveIfDifferent(peerId, peerPb, existingPeer);
+  }
+  async *all(query) {
+    for await (const {
+      key,
+      value
+    } of this.datastore.query(mapQuery(query ?? {}, this.maxAddressAge))) {
+      const peerId = keyToPeerId(key);
+      // skip self peer if present
+      if (peerId.equals(this.peerId)) {
+        continue;
+      }
+      const peer$1 = peer.Peer.decode(value);
+      // remove expired peer
+      if (this.#peerIsExpired(peerId, peer$1)) {
+        await this.datastore.delete(key);
+        continue;
+      }
+      yield bytesToPeer.pbToPeer(peerId, peer$1, this.peerId.equals(peerId) ? Infinity : this.maxAddressAge);
+    }
+  }
+  async #findExistingPeer(peerId) {
+    try {
+      const key = peerIdToDatastoreKey.peerIdToDatastoreKey(peerId);
+      const buf = await this.datastore.get(key);
+      const peerPB = peer.Peer.decode(buf);
+      // remove expired peer
+      if (this.#peerIsExpired(peerId, peerPB)) {
+        await this.datastore.delete(key);
+        throw new errors.NotFoundError();
+      }
+      return {
+        peerPB,
+        peer: bytesToPeer.bytesToPeer(peerId, buf, this.maxAddressAge)
+      };
+    } catch (err) {
+      if (err.name !== 'NotFoundError') {
+        this.log.error('invalid peer data found in peer store - %e', err);
+      }
+    }
+  }
+  async #saveIfDifferent(peerId, peer$1, existingPeer) {
+    // record last update
+    peer$1.updated = Date.now();
+    const buf = peer.Peer.encode(peer$1);
+    await this.datastore.put(peerIdToDatastoreKey.peerIdToDatastoreKey(peerId), buf);
+    return {
+      peer: bytesToPeer.bytesToPeer(peerId, buf, this.maxAddressAge),
+      previous: existingPeer?.peer,
+      updated: existingPeer == null || !peerEquals.peerEquals(peer$1, existingPeer.peerPB)
+    };
+  }
+  #peerIsExpired(peerId, peer) {
+    if (peer.updated == null) {
+      return true;
+    }
+    if (this.peerId.equals(peerId)) {
+      return false;
+    }
+    const expired = peer.updated < Date.now() - this.maxPeerAge;
+    const minAddressObserved = Date.now() - this.maxAddressAge;
+    const addrs = peer.addresses.filter(addr => {
+      return addr.observed != null && addr.observed > minAddressObserved;
+    });
+    return expired && addrs.length === 0;
+  }
+}
+
+exports.PersistentStore = PersistentStore;

package/dist/cjs/node_modules/@libp2p/peer-store/dist/src/utils/bytes-to-peer.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var index$1 = require('../../../../crypto/dist/src/keys/index.js');
+var index$2 = require('../../../../peer-id/dist/src/index.js');
+var index = require('../../../../../@multiformats/multiaddr/dist/src/index.js');
+var base58 = require('../../../../../multiformats/dist/src/bases/base58.js');
+var digest = require('../../../../../multiformats/dist/src/hashes/digest.js');
+var peer = require('../pb/peer.js');
+
+function populatePublicKey(peerId, protobuf) {
+  if (peerId.publicKey != null || protobuf.publicKey == null) {
+    return peerId;
+  }
+  let digest$1;
+  if (peerId.type === 'RSA') {
+    // avoid hashing public key
+    const multihash = base58.base58btc.decode(`z${peerId}`);
+    digest$1 = digest.decode(multihash);
+  }
+  const publicKey = index$1.publicKeyFromProtobuf(protobuf.publicKey, digest$1);
+  return index$2.peerIdFromPublicKey(publicKey);
+}
+function bytesToPeer(peerId, buf, maxAddressAge) {
+  const peer$1 = peer.Peer.decode(buf);
+  return pbToPeer(peerId, peer$1, maxAddressAge);
+}
+function pbToPeer(peerId, peer, maxAddressAge) {
+  const tags = new Map();
+  // remove any expired tags
+  const now = BigInt(Date.now());
+  for (const [key, tag] of peer.tags.entries()) {
+    if (tag.expiry != null && tag.expiry < now) {
+      continue;
+    }
+    tags.set(key, tag);
+  }
+  return {
+    ...peer,
+    id: populatePublicKey(peerId, peer),
+    addresses: peer.addresses
+    // remove any expired multiaddrs
+    .filter(_ref => {
+      let {
+        observed
+      } = _ref;
+      return observed != null && observed > Date.now() - maxAddressAge;
+    }).map(_ref2 => {
+      let {
+        multiaddr: ma,
+        isCertified
+      } = _ref2;
+      return {
+        multiaddr: index.multiaddr(ma),
+        isCertified: isCertified ?? false
+      };
+    }),
+    metadata: peer.metadata,
+    peerRecordEnvelope: peer.peerRecordEnvelope ?? undefined,
+    tags
+  };
+}
+
+exports.bytesToPeer = bytesToPeer;
+exports.pbToPeer = pbToPeer;

package/dist/cjs/node_modules/@libp2p/peer-store/dist/src/utils/dedupe-addresses.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var index = require('../../../../../@multiformats/multiaddr/dist/src/index.js');
+var errors = require('../../../../interface/dist/src/errors.js');
+
+async function dedupeFilterAndSortAddresses(peerId, filter, addresses, existingAddresses) {
+  const addressMap = new Map();
+  for (const addr of addresses) {
+    if (addr == null) {
+      continue;
+    }
+    if (addr.multiaddr instanceof Uint8Array) {
+      addr.multiaddr = index.multiaddr(addr.multiaddr);
+    }
+    if (!index.isMultiaddr(addr.multiaddr)) {
+      throw new errors.InvalidParametersError('Multiaddr was invalid');
+    }
+    if (!(await filter(peerId, addr.multiaddr))) {
+      continue;
+    }
+    const isCertified = addr.isCertified ?? false;
+    const maStr = addr.multiaddr.toString();
+    const existingAddr = addressMap.get(maStr);
+    if (existingAddr != null) {
+      addr.isCertified = existingAddr.isCertified || isCertified;
+    } else {
+      addressMap.set(maStr, {
+        multiaddr: addr.multiaddr,
+        isCertified
+      });
+    }
+  }
+  return [...addressMap.values()].sort((a, b) => {
+    return a.multiaddr.toString().localeCompare(b.multiaddr.toString());
+  }).map(_ref => {
+    let {
+      isCertified,
+      multiaddr: ma
+    } = _ref;
+    // strip the trailing peerId if it is present
+    const addrPeer = ma.getPeerId();
+    if (peerId.equals(addrPeer)) {
+      ma = ma.decapsulate(index.multiaddr(`/p2p/${peerId}`));
+    }
+    return {
+      isCertified,
+      multiaddr: ma.bytes
+    };
+  });
+}
+
+exports.dedupeFilterAndSortAddresses = dedupeFilterAndSortAddresses;