web-dc-api 0.0.61 → 0.0.62

package/dist/esm/node_modules/json-schema-traverse/index.js

@@ -0,0 +1,88 @@
+import { __module as jsonSchemaTraverse } from '../../_virtual/index26.js';
+
+var hasRequiredJsonSchemaTraverse;
+function requireJsonSchemaTraverse() {
+  if (hasRequiredJsonSchemaTraverse) return jsonSchemaTraverse.exports;
+  hasRequiredJsonSchemaTraverse = 1;
+  var traverse = jsonSchemaTraverse.exports = function (schema, opts, cb) {
+    // Legacy support for v0.3.1 and earlier.
+    if (typeof opts == 'function') {
+      cb = opts;
+      opts = {};
+    }
+    cb = opts.cb || cb;
+    var pre = typeof cb == 'function' ? cb : cb.pre || function () {};
+    var post = cb.post || function () {};
+    _traverse(opts, pre, post, schema, '', schema);
+  };
+  traverse.keywords = {
+    additionalItems: true,
+    items: true,
+    contains: true,
+    additionalProperties: true,
+    propertyNames: true,
+    not: true,
+    if: true,
+    then: true,
+    else: true
+  };
+  traverse.arrayKeywords = {
+    items: true,
+    allOf: true,
+    anyOf: true,
+    oneOf: true
+  };
+  traverse.propsKeywords = {
+    $defs: true,
+    definitions: true,
+    properties: true,
+    patternProperties: true,
+    dependencies: true
+  };
+  traverse.skipKeywords = {
+    default: true,
+    enum: true,
+    const: true,
+    required: true,
+    maximum: true,
+    minimum: true,
+    exclusiveMaximum: true,
+    exclusiveMinimum: true,
+    multipleOf: true,
+    maxLength: true,
+    minLength: true,
+    pattern: true,
+    format: true,
+    maxItems: true,
+    minItems: true,
+    uniqueItems: true,
+    maxProperties: true,
+    minProperties: true
+  };
+  function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
+    if (schema && typeof schema == 'object' && !Array.isArray(schema)) {
+      pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+      for (var key in schema) {
+        var sch = schema[key];
+        if (Array.isArray(sch)) {
+          if (key in traverse.arrayKeywords) {
+            for (var i = 0; i < sch.length; i++) _traverse(opts, pre, post, sch[i], jsonPtr + '/' + key + '/' + i, rootSchema, jsonPtr, key, schema, i);
+          }
+        } else if (key in traverse.propsKeywords) {
+          if (sch && typeof sch == 'object') {
+            for (var prop in sch) _traverse(opts, pre, post, sch[prop], jsonPtr + '/' + key + '/' + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
+          }
+        } else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) {
+          _traverse(opts, pre, post, sch, jsonPtr + '/' + key, rootSchema, jsonPtr, key, schema);
+        }
+      }
+      post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+    }
+  }
+  function escapeJsonPtr(str) {
+    return str.replace(/~/g, '~0').replace(/\//g, '~1');
+  }
+  return jsonSchemaTraverse.exports;
+}
+
+export { requireJsonSchemaTraverse as __require };

package/dist/esm/node_modules/jwt-decode/build/esm/index.js

@@ -0,0 +1,55 @@
+class InvalidTokenError extends Error {}
+InvalidTokenError.prototype.name = "InvalidTokenError";
+function b64DecodeUnicode(str) {
+  return decodeURIComponent(atob(str).replace(/(.)/g, (m, p) => {
+    let code = p.charCodeAt(0).toString(16).toUpperCase();
+    if (code.length < 2) {
+      code = "0" + code;
+    }
+    return "%" + code;
+  }));
+}
+function base64UrlDecode(str) {
+  let output = str.replace(/-/g, "+").replace(/_/g, "/");
+  switch (output.length % 4) {
+    case 0:
+      break;
+    case 2:
+      output += "==";
+      break;
+    case 3:
+      output += "=";
+      break;
+    default:
+      throw new Error("base64 string is not of the correct length");
+  }
+  try {
+    return b64DecodeUnicode(output);
+  } catch (err) {
+    return atob(output);
+  }
+}
+function jwtDecode(token, options) {
+  if (typeof token !== "string") {
+    throw new InvalidTokenError("Invalid token specified: must be a string");
+  }
+  options || (options = {});
+  const pos = options.header === true ? 0 : 1;
+  const part = token.split(".")[pos];
+  if (typeof part !== "string") {
+    throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
+  }
+  let decoded;
+  try {
+    decoded = base64UrlDecode(part);
+  } catch (e) {
+    throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`);
+  }
+  try {
+    return JSON.parse(decoded);
+  } catch (e) {
+    throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${e.message})`);
+  }
+}
+
+export { InvalidTokenError, jwtDecode };

package/dist/esm/node_modules/libp2p/dist/src/address-manager/dns-mappings.js

@@ -0,0 +1,136 @@
+import { isPrivateIp } from '../../../../@libp2p/utils/dist/src/private-ip.js';
+import { multiaddr } from '../../../../@multiformats/multiaddr/dist/src/index.js';
+import { getProtocol } from '../../../../@multiformats/multiaddr/dist/src/protocols-table.js';
+
+const MAX_DATE = 8_640_000_000_000_000;
+const CODEC_TLS = 0x01c0;
+const CODEC_SNI = 0x01c1;
+const CODEC_DNS = 0x35;
+const CODEC_DNS4 = 0x36;
+const CODEC_DNS6 = 0x37;
+const CODEC_DNSADDR = 0x38;
+class DNSMappings {
+  log;
+  mappings;
+  constructor(components) {
+    this.log = components.logger.forComponent('libp2p:address-manager:dns-mappings');
+    this.mappings = new Map();
+  }
+  has(ma) {
+    const host = this.findHost(ma);
+    for (const mapping of this.mappings.values()) {
+      if (mapping.domain === host) {
+        return true;
+      }
+    }
+    return false;
+  }
+  add(domain, addresses) {
+    addresses.forEach(ip => {
+      this.log('add DNS mapping %s to %s', ip, domain);
+      // we are only confident if this is an local domain mapping, otherwise
+      // we will require external validation
+      const verified = isPrivateIp(ip) === true;
+      this.mappings.set(ip, {
+        domain,
+        verified,
+        expires: verified ? MAX_DATE - Date.now() : 0,
+        lastVerified: verified ? MAX_DATE - Date.now() : undefined
+      });
+    });
+  }
+  remove(ma) {
+    const host = this.findHost(ma);
+    let wasConfident = false;
+    for (const [ip, mapping] of this.mappings.entries()) {
+      if (mapping.domain === host) {
+        this.log('removing %s to %s DNS mapping %e', ip, mapping.domain, new Error('where'));
+        this.mappings.delete(ip);
+        wasConfident = wasConfident || mapping.verified;
+      }
+    }
+    return wasConfident;
+  }
+  getAll(addresses) {
+    const dnsMappedAddresses = [];
+    for (let i = 0; i < addresses.length; i++) {
+      const address = addresses[i];
+      const tuples = address.multiaddr.stringTuples();
+      const host = tuples[0][1];
+      if (host == null) {
+        continue;
+      }
+      for (const [ip, mapping] of this.mappings.entries()) {
+        if (host !== ip) {
+          continue;
+        }
+        // insert SNI tuple after TLS tuple, if one is present
+        const mappedIp = this.maybeAddSNITuple(tuples, mapping.domain);
+        if (mappedIp) {
+          // remove the address and replace it with the version that includes
+          // the SNI tuple
+          addresses.splice(i, 1);
+          i--;
+          dnsMappedAddresses.push({
+            multiaddr: multiaddr(`/${tuples.map(tuple => {
+              return [getProtocol(tuple[0]).name, tuple[1]].join('/');
+            }).join('/')}`),
+            verified: mapping.verified,
+            type: 'dns-mapping',
+            expires: mapping.expires,
+            lastVerified: mapping.lastVerified
+          });
+        }
+      }
+    }
+    return dnsMappedAddresses;
+  }
+  maybeAddSNITuple(tuples, domain) {
+    for (let j = 0; j < tuples.length; j++) {
+      if (tuples[j][0] === CODEC_TLS && tuples[j + 1]?.[0] !== CODEC_SNI) {
+        tuples.splice(j + 1, 0, [CODEC_SNI, domain]);
+        return true;
+      }
+    }
+    return false;
+  }
+  confirm(ma, ttl) {
+    const host = this.findHost(ma);
+    let startingConfidence = false;
+    for (const [ip, mapping] of this.mappings.entries()) {
+      if (mapping.domain === host) {
+        this.log('marking %s to %s DNS mapping as verified', ip, mapping.domain);
+        startingConfidence = mapping.verified;
+        mapping.verified = true;
+        mapping.expires = Date.now() + ttl;
+        mapping.lastVerified = Date.now();
+      }
+    }
+    return startingConfidence;
+  }
+  unconfirm(ma, ttl) {
+    const host = this.findHost(ma);
+    let wasConfident = false;
+    for (const [ip, mapping] of this.mappings.entries()) {
+      if (mapping.domain === host) {
+        this.log('removing verification of %s to %s DNS mapping', ip, mapping.domain);
+        wasConfident = wasConfident || mapping.verified;
+        mapping.verified = false;
+        mapping.expires = Date.now() + ttl;
+      }
+    }
+    return wasConfident;
+  }
+  findHost(ma) {
+    for (const tuple of ma.stringTuples()) {
+      if (tuple[0] === CODEC_SNI) {
+        return tuple[1];
+      }
+      if (tuple[0] === CODEC_DNS || tuple[0] === CODEC_DNS4 || tuple[0] === CODEC_DNS6 || tuple[0] === CODEC_DNSADDR) {
+        return tuple[1];
+      }
+    }
+  }
+}
+
+export { DNSMappings };

package/dist/esm/node_modules/libp2p/dist/src/address-manager/index.js

@@ -0,0 +1,349 @@
+import { isIPv4 } from '../../../../@chainsafe/is-ip/lib/is-ip.js';
+import { peerIdFromString } from '../../../../@libp2p/peer-id/dist/src/index.js';
+import { debounce } from '../../../../@libp2p/utils/dist/src/debounce.js';
+import { isPrivateIp } from '../../../../@libp2p/utils/dist/src/private-ip.js';
+import { multiaddr } from '../../../../@multiformats/multiaddr/dist/src/index.js';
+import { WebSockets, WebSocketsSecure, TCP, QUICV1 } from '../../../../@multiformats/multiaddr-matcher/dist/src/index.js';
+import { DNSMappings } from './dns-mappings.js';
+import { IPMappings } from './ip-mappings.js';
+import { ObservedAddresses } from './observed-addresses.js';
+import { TransportAddresses } from './transport-addresses.js';
+import { createScalableCuckooFilter } from '../../../../@libp2p/utils/dist/src/filters/scalable-cuckoo-filter.js';
+
+/* eslint-disable complexity */
+const ONE_MINUTE = 60_000;
+const defaultValues = {
+  addressVerificationTTL: ONE_MINUTE * 10,
+  addressVerificationRetry: ONE_MINUTE * 5
+};
+const defaultAddressFilter = addrs => addrs;
+/**
+ * If the passed multiaddr contains the passed peer id, remove it
+ */
+function stripPeerId(ma, peerId) {
+  const observedPeerIdStr = ma.getPeerId();
+  // strip our peer id if it has been passed
+  if (observedPeerIdStr != null) {
+    const observedPeerId = peerIdFromString(observedPeerIdStr);
+    // use same encoding for comparison
+    if (observedPeerId.equals(peerId)) {
+      ma = ma.decapsulate(multiaddr(`/p2p/${peerId.toString()}`));
+    }
+  }
+  return ma;
+}
+class AddressManager {
+  log;
+  components;
+  // this is an array to allow for duplicates, e.g. multiples of `/ip4/0.0.0.0/tcp/0`
+  listen;
+  announce;
+  appendAnnounce;
+  announceFilter;
+  observed;
+  dnsMappings;
+  ipMappings;
+  transportAddresses;
+  observedAddressFilter;
+  addressVerificationTTL;
+  addressVerificationRetry;
+  /**
+   * Responsible for managing the peer addresses.
+   * Peers can specify their listen and announce addresses.
+   * The listen addresses will be used by the libp2p transports to listen for new connections,
+   * while the announce addresses will be used for the peer addresses' to other peers in the network.
+   */
+  constructor(components) {
+    let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const {
+      listen = [],
+      announce = [],
+      appendAnnounce = []
+    } = init;
+    this.components = components;
+    this.log = components.logger.forComponent('libp2p:address-manager');
+    this.listen = listen.map(ma => ma.toString());
+    this.announce = new Set(announce.map(ma => ma.toString()));
+    this.appendAnnounce = new Set(appendAnnounce.map(ma => ma.toString()));
+    this.observed = new ObservedAddresses(components, init);
+    this.dnsMappings = new DNSMappings(components, init);
+    this.ipMappings = new IPMappings(components, init);
+    this.transportAddresses = new TransportAddresses(components, init);
+    this.announceFilter = init.announceFilter ?? defaultAddressFilter;
+    this.observedAddressFilter = createScalableCuckooFilter(1024);
+    this.addressVerificationTTL = init.addressVerificationTTL ?? defaultValues.addressVerificationTTL;
+    this.addressVerificationRetry = init.addressVerificationRetry ?? defaultValues.addressVerificationRetry;
+    // this method gets called repeatedly on startup when transports start listening so
+    // debounce it so we don't cause multiple self:peer:update events to be emitted
+    this._updatePeerStoreAddresses = debounce(this._updatePeerStoreAddresses.bind(this), 1000);
+    // update our stored addresses when new transports listen
+    components.events.addEventListener('transport:listening', () => {
+      this._updatePeerStoreAddresses();
+    });
+    // update our stored addresses when existing transports stop listening
+    components.events.addEventListener('transport:close', () => {
+      this._updatePeerStoreAddresses();
+    });
+  }
+  [Symbol.toStringTag] = '@libp2p/address-manager';
+  _updatePeerStoreAddresses() {
+    // if announce addresses have been configured, ensure they make it into our peer
+    // record for things like identify
+    const addrs = this.getAddresses().map(ma => {
+      // strip our peer id if it is present
+      if (ma.getPeerId() === this.components.peerId.toString()) {
+        return ma.decapsulate(`/p2p/${this.components.peerId.toString()}`);
+      }
+      return ma;
+    });
+    this.components.peerStore.patch(this.components.peerId, {
+      multiaddrs: addrs
+    }).catch(err => {
+      this.log.error('error updating addresses', err);
+    });
+  }
+  /**
+   * Get peer listen multiaddrs
+   */
+  getListenAddrs() {
+    return Array.from(this.listen).map(a => multiaddr(a));
+  }
+  /**
+   * Get peer announcing multiaddrs
+   */
+  getAnnounceAddrs() {
+    return Array.from(this.announce).map(a => multiaddr(a));
+  }
+  /**
+   * Get peer announcing multiaddrs
+   */
+  getAppendAnnounceAddrs() {
+    return Array.from(this.appendAnnounce).map(a => multiaddr(a));
+  }
+  /**
+   * Get observed multiaddrs
+   */
+  getObservedAddrs() {
+    return this.observed.getAll().map(addr => addr.multiaddr);
+  }
+  /**
+   * Add peer observed addresses
+   */
+  addObservedAddr(addr) {
+    const tuples = addr.stringTuples();
+    const socketAddress = `${tuples[0][1]}:${tuples[1][1]}`;
+    // ignore if this address if it's been observed before
+    if (this.observedAddressFilter.has(socketAddress)) {
+      return;
+    }
+    this.observedAddressFilter.add(socketAddress);
+    addr = stripPeerId(addr, this.components.peerId);
+    // ignore observed address if it is an IP mapping
+    if (this.ipMappings.has(addr)) {
+      return;
+    }
+    // ignore observed address if it is a DNS mapping
+    if (this.dnsMappings.has(addr)) {
+      return;
+    }
+    this.observed.add(addr);
+  }
+  confirmObservedAddr(addr, options) {
+    addr = stripPeerId(addr, this.components.peerId);
+    let startingConfidence = true;
+    if (options?.type === 'transport' || this.transportAddresses.has(addr)) {
+      const transportStartingConfidence = this.transportAddresses.confirm(addr, options?.ttl ?? this.addressVerificationTTL);
+      if (!transportStartingConfidence && startingConfidence) {
+        startingConfidence = false;
+      }
+    }
+    if (options?.type === 'dns-mapping' || this.dnsMappings.has(addr)) {
+      const dnsMappingStartingConfidence = this.dnsMappings.confirm(addr, options?.ttl ?? this.addressVerificationTTL);
+      if (!dnsMappingStartingConfidence && startingConfidence) {
+        startingConfidence = false;
+      }
+    }
+    if (options?.type === 'ip-mapping' || this.ipMappings.has(addr)) {
+      const ipMappingStartingConfidence = this.ipMappings.confirm(addr, options?.ttl ?? this.addressVerificationTTL);
+      if (!ipMappingStartingConfidence && startingConfidence) {
+        startingConfidence = false;
+      }
+    }
+    if (options?.type === 'observed' || this.observed.has(addr)) {
+      // try to match up observed address with local transport listener
+      if (this.maybeUpgradeToIPMapping(addr)) {
+        this.ipMappings.confirm(addr, options?.ttl ?? this.addressVerificationTTL);
+        startingConfidence = false;
+      } else {
+        const observedStartingConfidence = this.observed.confirm(addr, options?.ttl ?? this.addressVerificationTTL);
+        if (!observedStartingConfidence && startingConfidence) {
+          startingConfidence = false;
+        }
+      }
+    }
+    // only trigger the 'self:peer:update' event if our confidence in an address has changed
+    if (!startingConfidence) {
+      this._updatePeerStoreAddresses();
+    }
+  }
+  removeObservedAddr(addr, options) {
+    addr = stripPeerId(addr, this.components.peerId);
+    if (this.observed.has(addr)) {
+      this.observed.remove(addr);
+    }
+    if (this.transportAddresses.has(addr)) {
+      this.transportAddresses.unconfirm(addr, options?.ttl ?? this.addressVerificationRetry);
+    }
+    if (this.dnsMappings.has(addr)) {
+      this.dnsMappings.unconfirm(addr, options?.ttl ?? this.addressVerificationRetry);
+    }
+    if (this.ipMappings.has(addr)) {
+      this.ipMappings.unconfirm(addr, options?.ttl ?? this.addressVerificationRetry);
+    }
+  }
+  getAddresses() {
+    const addresses = new Set();
+    const multiaddrs = this.getAddressesWithMetadata().filter(addr => {
+      if (!addr.verified) {
+        return false;
+      }
+      const maStr = addr.multiaddr.toString();
+      if (addresses.has(maStr)) {
+        return false;
+      }
+      addresses.add(maStr);
+      return true;
+    }).map(address => address.multiaddr);
+    // filter addressees before returning
+    return this.announceFilter(multiaddrs.map(str => {
+      const ma = multiaddr(str);
+      // do not append our peer id to a path multiaddr as it will become invalid
+      if (ma.protos().pop()?.path === true) {
+        return ma;
+      }
+      if (ma.getPeerId() === this.components.peerId.toString()) {
+        return ma;
+      }
+      return ma.encapsulate(`/p2p/${this.components.peerId.toString()}`);
+    }));
+  }
+  getAddressesWithMetadata() {
+    const announceMultiaddrs = this.getAnnounceAddrs();
+    if (announceMultiaddrs.length > 0) {
+      // allow transports to add certhashes and other runtime information
+      this.components.transportManager.getListeners().forEach(listener => {
+        listener.updateAnnounceAddrs(announceMultiaddrs);
+      });
+      return announceMultiaddrs.map(multiaddr => ({
+        multiaddr,
+        verified: true,
+        type: 'announce',
+        expires: Date.now() + this.addressVerificationTTL,
+        lastVerified: Date.now()
+      }));
+    }
+    let addresses = [];
+    // add transport addresses
+    addresses = addresses.concat(this.components.transportManager.getAddrs().map(multiaddr => this.transportAddresses.get(multiaddr, this.addressVerificationTTL)));
+    const appendAnnounceMultiaddrs = this.getAppendAnnounceAddrs();
+    // add append announce addresses
+    if (appendAnnounceMultiaddrs.length > 0) {
+      // allow transports to add certhashes and other runtime information
+      this.components.transportManager.getListeners().forEach(listener => {
+        listener.updateAnnounceAddrs(appendAnnounceMultiaddrs);
+      });
+      addresses = addresses.concat(appendAnnounceMultiaddrs.map(multiaddr => ({
+        multiaddr,
+        verified: true,
+        type: 'announce',
+        expires: Date.now() + this.addressVerificationTTL,
+        lastVerified: Date.now()
+      })));
+    }
+    // add observed addresses
+    addresses = addresses.concat(this.observed.getAll());
+    // add ip mapped addresses
+    addresses = addresses.concat(this.ipMappings.getAll(addresses));
+    // add ip->domain mappings, must be done after IP mappings
+    addresses = addresses.concat(this.dnsMappings.getAll(addresses));
+    return addresses;
+  }
+  addDNSMapping(domain, addresses) {
+    this.dnsMappings.add(domain, addresses);
+  }
+  removeDNSMapping(domain) {
+    if (this.dnsMappings.remove(multiaddr(`/dns/${domain}`))) {
+      this._updatePeerStoreAddresses();
+    }
+  }
+  addPublicAddressMapping(internalIp, internalPort, externalIp) {
+    let externalPort = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : internalPort;
+    let protocol = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 'tcp';
+    this.ipMappings.add(internalIp, internalPort, externalIp, externalPort, protocol);
+    // remove duplicate observed addresses
+    this.observed.removePrefixed(`/ip${isIPv4(externalIp) ? 4 : 6}/${externalIp}/${protocol}/${externalPort}`);
+  }
+  removePublicAddressMapping(internalIp, internalPort, externalIp) {
+    let externalPort = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : internalPort;
+    let protocol = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 'tcp';
+    if (this.ipMappings.remove(multiaddr(`/ip${isIPv4(externalIp) ? 4 : 6}/${externalIp}/${protocol}/${externalPort}`))) {
+      this._updatePeerStoreAddresses();
+    }
+  }
+  /**
+   * Where an external service (router, gateway, etc) is forwarding traffic to
+   * us, attempt to add an IP mapping for the external address - this will
+   * include the observed mapping in the address list where we also have a DNS
+   * mapping for the external IP.
+   *
+   * Returns true if we added a new mapping
+   */
+  maybeUpgradeToIPMapping(ma) {
+    // this address is already mapped
+    if (this.ipMappings.has(ma)) {
+      return false;
+    }
+    const maOptions = ma.toOptions();
+    // only public IPv4 addresses
+    if (maOptions.family === 6 || maOptions.host === '127.0.0.1' || isPrivateIp(maOptions.host) === true) {
+      return false;
+    }
+    const listeners = this.components.transportManager.getListeners();
+    const transportMatchers = [ma => WebSockets.exactMatch(ma) || WebSocketsSecure.exactMatch(ma), ma => TCP.exactMatch(ma), ma => QUICV1.exactMatch(ma)];
+    for (const matcher of transportMatchers) {
+      // is the incoming address the same type as the matcher
+      if (!matcher(ma)) {
+        continue;
+      }
+      // get the listeners for this transport
+      const transportListeners = listeners.filter(listener => {
+        return listener.getAddrs().filter(ma => {
+          // only IPv4 addresses of the matcher type
+          return ma.toOptions().family === 4 && matcher(ma);
+        }).length > 0;
+      });
+      // because the NAT mapping could be forwarding different external ports to
+      // internal ones, we can only be sure enough to add a mapping if there is
+      // a single listener
+      if (transportListeners.length !== 1) {
+        continue;
+      }
+      // we have one listener which listens on one port so whatever the external
+      // NAT port mapping is, it should be for this listener
+      const linkLocalAddr = transportListeners[0].getAddrs().filter(ma => {
+        return ma.toOptions().host !== '127.0.0.1';
+      }).pop();
+      if (linkLocalAddr == null) {
+        continue;
+      }
+      const linkLocalOptions = linkLocalAddr.toOptions();
+      // upgrade observed address to IP mapping
+      this.observed.remove(ma);
+      this.ipMappings.add(linkLocalOptions.host, linkLocalOptions.port, maOptions.host, maOptions.port, maOptions.transport);
+      return true;
+    }
+    return false;
+  }
+}
+
+export { AddressManager, defaultValues };