web-dc-api 0.0.58 → 0.0.59

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

@@ -0,0 +1,167 @@
+'use strict';
+
+var index$1 = require('../../../crypto/dist/src/keys/index.js');
+var _interface = require('@libp2p/interface');
+var peerId = require('@libp2p/peer-id');
+var isGlobalUnicast = require('../../../utils/dist/src/multiaddr/is-global-unicast.js');
+var isPrivate = require('../../../utils/dist/src/multiaddr/is-private.js');
+var multiaddr = require('@multiformats/multiaddr');
+var index$2 = require('../../../../@multiformats/multiaddr-matcher/dist/src/index.js');
+var index = require('../../../../it-protobuf-stream/dist/src/index.js');
+var consts = require('./consts.js');
+var message = require('./pb/message.js');
+var utils = require('./utils.js');
+var index$3 = require('../../../peer-record/dist/src/peer-record/index.js');
+var index$4 = require('../../../peer-record/dist/src/envelope/index.js');
+
+const CODEC_IP6 = 0x29;
+class Identify extends utils.AbstractIdentify {
+  constructor(components) {
+    let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    super(components, {
+      ...init,
+      protocol: `/${init.protocolPrefix ?? utils.defaultValues.protocolPrefix}/${consts.MULTICODEC_IDENTIFY_PROTOCOL_NAME}/${consts.MULTICODEC_IDENTIFY_PROTOCOL_VERSION}`,
+      log: components.logger.forComponent('libp2p:identify')
+    });
+    if (init.runOnConnectionOpen ?? utils.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 === _interface.UnsupportedProtocolError.name) {
+            // the remote did not support identify, ignore the error
+            return;
+          }
+          this.log.error('error during identify trigged by connection:open', err);
+        });
+      });
+    }
+  }
+  [_interface.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);
+      _interface.setMaxListeners(Infinity, signal);
+      options = {
+        ...options,
+        signal
+      };
+    }
+    try {
+      stream = await connection.newStream(this.protocol, {
+        ...options,
+        runOnLimitedConnection: this.runOnLimitedConnection
+      });
+      const pb = index.pbStream(stream, {
+        maxDataLength: this.maxMessageSize
+      }).pb(message.Identify);
+      const message$1 = await pb.read(options);
+      await stream.close(options);
+      return message$1;
+    } 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 _interface.InvalidMessageError('public key was missing from identify message');
+    }
+    const key = index$1.publicKeyFromProtobuf(publicKey);
+    const id = peerId.peerIdFromCID(key.toCID());
+    if (!connection.remotePeer.equals(id)) {
+      throw new _interface.InvalidMessageError('identified peer does not match the expected peer');
+    }
+    if (this.peerId.equals(id)) {
+      throw new _interface.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 utils.consumeIdentifyMessage(this.peerStore, this.events, this.log, connection, message);
+  }
+  maybeAddObservedAddress(observedAddr) {
+    const cleanObservedAddr = utils.getCleanMultiaddr(observedAddr);
+    if (cleanObservedAddr == null) {
+      return;
+    }
+    this.log.trace('our observed address was %a', cleanObservedAddr);
+    if (isPrivate.isPrivate(cleanObservedAddr)) {
+      this.log.trace('our observed address was private');
+      return;
+    }
+    const tuples = cleanObservedAddr.stringTuples();
+    if (tuples[0][0] === CODEC_IP6 && !isGlobalUnicast.isGlobalUnicast(cleanObservedAddr)) {
+      this.log.trace('our observed address was IPv6 but not a global unicast address');
+      return;
+    }
+    if (index$2.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);
+    _interface.setMaxListeners(Infinity, signal);
+    try {
+      const peerData = await this.peerStore.get(this.peerId);
+      const multiaddrs = this.addressManager.getAddresses().map(ma => ma.decapsulateCode(multiaddr.protocols('p2p').code));
+      let signedPeerRecord = peerData.peerRecordEnvelope;
+      if (multiaddrs.length > 0 && signedPeerRecord == null) {
+        const peerRecord = new index$3.PeerRecord({
+          peerId: this.peerId,
+          multiaddrs
+        });
+        const envelope = await index$4.RecordEnvelope.seal(peerRecord, this.privateKey);
+        signedPeerRecord = envelope.marshal().subarray();
+      }
+      let observedAddr = connection.remoteAddr.bytes;
+      if (!index$2.IP_OR_DOMAIN.matches(connection.remoteAddr)) {
+        observedAddr = undefined;
+      }
+      const pb = index.pbStream(stream).pb(message.Identify);
+      await pb.write({
+        protocolVersion: this.host.protocolVersion,
+        agentVersion: this.host.agentVersion,
+        publicKey: index$1.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);
+    }
+  }
+}
+
+exports.Identify = Identify;

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

@@ -0,0 +1,58 @@
+'use strict';
+
+var identifyPush$1 = require('./identify-push.js');
+var identify$1 = require('./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$1.Identify(components, init);
+}
+function identifyPush() {
+  let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return components => new identifyPush$1.IdentifyPush(components, init);
+}
+
+exports.identify = identify;
+exports.identifyPush = identifyPush;

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

@@ -0,0 +1,122 @@
+'use strict';
+
+var index = require('../../../../../protons-runtime/dist/src/index.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');
+
+exports.Identify = void 0;
+(function (Identify) {
+  let _codec;
+  Identify.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.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 index.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 index.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 encode.encodeMessage(obj, Identify.codec());
+  };
+  Identify.decode = (buf, opts) => {
+    return decode.decodeMessage(buf, Identify.codec(), opts);
+  };
+})(exports.Identify || (exports.Identify = {}));

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

@@ -0,0 +1,220 @@
+'use strict';
+
+var index = require('../../../crypto/dist/src/keys/index.js');
+var _interface = require('@libp2p/interface');
+var peerId = require('@libp2p/peer-id');
+var multiaddr = require('@multiformats/multiaddr');
+var fromString = require('../../../../uint8arrays/dist/src/from-string.js');
+var consts = require('./consts.js');
+var index$1 = require('../../../peer-record/dist/src/envelope/index.js');
+var index$2 = require('../../../peer-record/dist/src/peer-record/index.js');
+
+const defaultValues = {
+  protocolPrefix: 'ipfs',
+  timeout: 5000,
+  maxInboundStreams: 1,
+  maxOutboundStreams: 1,
+  maxObservedAddresses: 10,
+  maxMessageSize: consts.MAX_IDENTIFY_MESSAGE_SIZE,
+  runOnConnectionOpen: true,
+  runOnSelfUpdate: true,
+  runOnLimitedConnection: true,
+  concurrency: consts.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.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 _interface.InvalidMessageError('message was null or undefined');
+  }
+  const peer = {};
+  if (message.listenAddrs.length > 0) {
+    peer.addresses = message.listenAddrs.map(buf => ({
+      isCertified: false,
+      multiaddr: multiaddr.multiaddr(buf)
+    }));
+  }
+  if (message.protocols.length > 0) {
+    peer.protocols = message.protocols;
+  }
+  if (message.publicKey != null) {
+    const publicKey = index.publicKeyFromProtobuf(message.publicKey);
+    const peerId$1 = peerId.peerIdFromPublicKey(publicKey);
+    if (!peerId$1.equals(connection.remotePeer)) {
+      throw new _interface.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 index$1.RecordEnvelope.openAndCertify(peerRecordEnvelope, index$2.PeerRecord.DOMAIN);
+    let peerRecord = index$2.PeerRecord.createFromProtobuf(envelope.payload);
+    const envelopePeer = peerId.peerIdFromCID(envelope.publicKey.toCID());
+    // Verify peerId
+    if (!peerRecord.peerId.equals(envelopePeer)) {
+      throw new _interface.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 _interface.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 index$1.RecordEnvelope.createFromProtobuf(existingPeer.peerRecordEnvelope);
+        const storedRecord = index$2.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.fromString(message.agentVersion);
+    }
+    if (message.protocolVersion != null) {
+      metadata.ProtocolVersion = fromString.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.multiaddr(buf)),
+    observedAddr: message.observedAddr == null ? undefined : multiaddr.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}/${consts.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.fromString(this.host.agentVersion),
+        ProtocolVersion: fromString.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;
+  }
+}
+
+exports.AbstractIdentify = AbstractIdentify;
+exports.consumeIdentifyMessage = consumeIdentifyMessage;
+exports.defaultValues = defaultValues;
+exports.getAgentVersion = getAgentVersion;
+exports.getCleanMultiaddr = getCleanMultiaddr;

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

@@ -0,0 +1,120 @@
+'use strict';
+
+var base32 = require('../../../../multiformats/dist/src/bases/base32.js');
+var base58 = require('../../../../multiformats/dist/src/bases/base58.js');
+var base64 = require('../../../../multiformats/dist/src/bases/base64.js');
+var browser = require('../../../../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
+browser.default.formatters.b = v => {
+  return v == null ? 'undefined' : base58.base58btc.baseEncode(v);
+};
+// Add a formatter for converting to a base32 string
+browser.default.formatters.t = v => {
+  return v == null ? 'undefined' : base32.base32.baseEncode(v);
+};
+// Add a formatter for converting to a base64 string
+browser.default.formatters.m = v => {
+  return v == null ? 'undefined' : base64.base64.baseEncode(v);
+};
+// Add a formatter for stringifying peer ids
+browser.default.formatters.p = v => {
+  return v == null ? 'undefined' : v.toString();
+};
+// Add a formatter for stringifying CIDs
+browser.default.formatters.c = v => {
+  return v == null ? 'undefined' : v.toString();
+};
+// Add a formatter for stringifying Datastore keys
+browser.default.formatters.k = v => {
+  return v == null ? 'undefined' : v.toString();
+};
+// Add a formatter for stringifying Multiaddrs
+browser.default.formatters.a = v => {
+  return v == null ? 'undefined' : v.toString();
+};
+// Add a formatter for stringifying Errors
+browser.default.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 (browser.default.enabled(`${name}:trace`) && browser.default.names.map(r => r.toString()).find(n => n.includes(':trace')) != null) {
+    trace = browser.default(`${name}:trace`);
+  }
+  return Object.assign(browser.default(name), {
+    error: browser.default(`${name}:error`),
+    trace
+  });
+}
+function notEmpty(str) {
+  if (str == null) {
+    return;
+  }
+  str = str.trim();
+  if (str.length === 0) {
+    return;
+  }
+  return str;
+}
+
+exports.logger = logger;