web-dc-api 0.0.58 → 0.0.60

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

@@ -0,0 +1,125 @@
+import { publicKeyFromProtobuf, publicKeyToProtobuf } from '../../../../crypto/dist/src/keys/index.js';
+import { encode } from '../../../../../uint8-varint/dist/src/index.js';
+import { Uint8ArrayList } from '../../../../../uint8arraylist/dist/src/index.js';
+import { equals } from '../../../../../uint8arrays/dist/src/equals.js';
+import { fromString } from '../../../../../uint8arrays/dist/src/from-string.js';
+import { Envelope } from './envelope.js';
+import { InvalidSignatureError } from './errors.js';
+
+class RecordEnvelope {
+  /**
+   * Unmarshal a serialized Envelope protobuf message
+   */
+  static createFromProtobuf = async data => {
+    const envelopeData = Envelope.decode(data);
+    const publicKey = 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 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.encode({
+        publicKey: 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(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(domain);
+  const domainLength = encode(domainUint8Array.byteLength);
+  const payloadTypeLength = encode(payloadType.length);
+  const payloadLength = encode(payload.length);
+  return new Uint8ArrayList(domainLength, domainUint8Array, payloadTypeLength, payloadType, payloadLength, payload);
+};
+
+export { RecordEnvelope };

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

@@ -0,0 +1,8 @@
+// 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]);
+
+export { ENVELOPE_DOMAIN_PEER_RECORD, ENVELOPE_PAYLOAD_TYPE_PEER_RECORD };

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

@@ -0,0 +1,83 @@
+import { peerIdFromMultihash } from '@libp2p/peer-id';
+import { arrayEquals } from '../../../../utils/dist/src/array-equals.js';
+import { multiaddr } from '@multiformats/multiaddr';
+import { decode } from '../../../../../multiformats/dist/src/hashes/digest.js';
+import { ENVELOPE_DOMAIN_PEER_RECORD, ENVELOPE_PAYLOAD_TYPE_PEER_RECORD } from './consts.js';
+import { PeerRecord as PeerRecord$1 } from './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 = PeerRecord$1.decode(buf);
+    const peerId = peerIdFromMultihash(decode(peerRecord.peerId));
+    const multiaddrs = (peerRecord.addresses ?? []).map(a => multiaddr(a.multiaddr));
+    const seqNumber = peerRecord.seq;
+    return new PeerRecord({
+      peerId,
+      multiaddrs,
+      seqNumber
+    });
+  };
+  static DOMAIN = (() => ENVELOPE_DOMAIN_PEER_RECORD)();
+  static CODEC = (() => 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$1.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(this.multiaddrs, other.multiaddrs)) {
+      return false;
+    }
+    return true;
+  }
+}
+
+export { PeerRecord };

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

@@ -0,0 +1,133 @@
+import { MaxLengthError } from '../../../../../protons-runtime/dist/src/index.js';
+import { alloc } from '../../../../../uint8arrays/dist/src/alloc.js';
+import { message } from '../../../../../protons-runtime/dist/src/codecs/message.js';
+import { encodeMessage } from '../../../../../protons-runtime/dist/src/encode.js';
+import { decodeMessage } from '../../../../../protons-runtime/dist/src/decode.js';
+
+var PeerRecord$1;
+(function (PeerRecord) {
+  (function (AddressInfo) {
+    let _codec;
+    AddressInfo.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.multiaddr != null && obj.multiaddr.byteLength > 0) {
+            w.uint32(10);
+            w.bytes(obj.multiaddr);
+          }
+          if (opts.lengthDelimited !== false) {
+            w.ldelim();
+          }
+        }, function (reader, length) {
+          const obj = {
+            multiaddr: 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;
+                }
+              default:
+                {
+                  reader.skipType(tag & 7);
+                  break;
+                }
+            }
+          }
+          return obj;
+        });
+      }
+      return _codec;
+    };
+    AddressInfo.encode = obj => {
+      return encodeMessage(obj, AddressInfo.codec());
+    };
+    AddressInfo.decode = (buf, opts) => {
+      return decodeMessage(buf, AddressInfo.codec(), opts);
+    };
+  })(PeerRecord.AddressInfo || (PeerRecord.AddressInfo = {}));
+  let _codec;
+  PeerRecord.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.peerId != null && obj.peerId.byteLength > 0) {
+          w.uint32(10);
+          w.bytes(obj.peerId);
+        }
+        if (obj.seq != null && obj.seq !== 0n) {
+          w.uint32(16);
+          w.uint64(obj.seq);
+        }
+        if (obj.addresses != null) {
+          for (const value of obj.addresses) {
+            w.uint32(26);
+            PeerRecord.AddressInfo.codec().encode(value, w);
+          }
+        }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim();
+        }
+      }, function (reader, length) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        const obj = {
+          peerId: alloc(0),
+          seq: 0n,
+          addresses: []
+        };
+        const end = length == null ? reader.len : reader.pos + length;
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1:
+              {
+                obj.peerId = reader.bytes();
+                break;
+              }
+            case 2:
+              {
+                obj.seq = reader.uint64();
+                break;
+              }
+            case 3:
+              {
+                if (opts.limits?.addresses != null && obj.addresses.length === opts.limits.addresses) {
+                  throw new MaxLengthError('Decode error - map field "addresses" had too many elements');
+                }
+                obj.addresses.push(PeerRecord.AddressInfo.codec().decode(reader, reader.uint32(), {
+                  limits: opts.limits?.addresses$
+                }));
+                break;
+              }
+            default:
+              {
+                reader.skipType(tag & 7);
+                break;
+              }
+          }
+        }
+        return obj;
+      });
+    }
+    return _codec;
+  };
+  PeerRecord.encode = obj => {
+    return encodeMessage(obj, PeerRecord.codec());
+  };
+  PeerRecord.decode = (buf, opts) => {
+    return decodeMessage(buf, PeerRecord.codec(), opts);
+  };
+})(PeerRecord$1 || (PeerRecord$1 = {}));
+
+export { PeerRecord$1 as PeerRecord };

package/dist/esm/node_modules/@libp2p/ping/dist/src/constants.js

@@ -0,0 +1,15 @@
+const PING_LENGTH = 32;
+const PROTOCOL_VERSION = '1.0.0';
+const PROTOCOL_NAME = 'ping';
+const PROTOCOL_PREFIX = 'ipfs';
+const TIMEOUT = 10000;
+// See https://github.com/libp2p/specs/blob/d4b5fb0152a6bb86cfd9ea/ping/ping.md?plain=1#L38-L43
+// The dialing peer MUST NOT keep more than one outbound stream for the ping protocol per peer.
+// The listening peer SHOULD accept at most two streams per peer since cross-stream behavior is
+// non-linear and stream writes occur asynchronously. The listening peer may perceive the
+// dialing peer closing and opening the wrong streams (for instance, closing stream B and
+// opening stream A even though the dialing peer is opening stream B and closing stream A).
+const MAX_INBOUND_STREAMS = 2;
+const MAX_OUTBOUND_STREAMS = 1;
+
+export { MAX_INBOUND_STREAMS, MAX_OUTBOUND_STREAMS, PING_LENGTH, PROTOCOL_NAME, PROTOCOL_PREFIX, PROTOCOL_VERSION, TIMEOUT };

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

@@ -0,0 +1,31 @@
+import { Ping } from './ping.js';
+
+/**
+ * @packageDocumentation
+ *
+ * The ping service implements the [libp2p ping spec](https://github.com/libp2p/specs/blob/master/ping/ping.md) allowing you to make a latency measurement to a remote peer.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { createLibp2p } from 'libp2p'
+ * import { ping } from '@libp2p/ping'
+ * import { multiaddr } from '@multiformats/multiaddr'
+ *
+ * const node = await createLibp2p({
+ *   services: {
+ *     ping: ping()
+ *   }
+ * })
+ *
+ * const rtt = await node.services.ping.ping(multiaddr('/ip4/...'))
+ *
+ * console.info(rtt)
+ * ```
+ */
+function ping() {
+  let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return components => new Ping(components, init);
+}
+
+export { ping };

package/dist/esm/node_modules/@libp2p/ping/dist/src/ping.js

@@ -0,0 +1,138 @@
+import { randomBytes } from '@libp2p/crypto';
+import { serviceCapabilities, setMaxListeners, TimeoutError, ProtocolError } from '@libp2p/interface';
+import { byteStream } from '../../../../it-byte-stream/dist/src/index.js';
+import { equals } from '../../../../uint8arrays/dist/src/equals.js';
+import { PROTOCOL_PREFIX, PROTOCOL_NAME, PROTOCOL_VERSION, TIMEOUT, MAX_INBOUND_STREAMS, MAX_OUTBOUND_STREAMS, PING_LENGTH } from './constants.js';
+
+class Ping {
+  protocol;
+  components;
+  started;
+  timeout;
+  maxInboundStreams;
+  maxOutboundStreams;
+  runOnLimitedConnection;
+  log;
+  constructor(components) {
+    let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    this.components = components;
+    this.log = components.logger.forComponent('libp2p:ping');
+    this.started = false;
+    this.protocol = `/${init.protocolPrefix ?? PROTOCOL_PREFIX}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`;
+    this.timeout = init.timeout ?? TIMEOUT;
+    this.maxInboundStreams = init.maxInboundStreams ?? MAX_INBOUND_STREAMS;
+    this.maxOutboundStreams = init.maxOutboundStreams ?? MAX_OUTBOUND_STREAMS;
+    this.runOnLimitedConnection = init.runOnLimitedConnection ?? true;
+    this.handleMessage = this.handleMessage.bind(this);
+  }
+  [Symbol.toStringTag] = '@libp2p/ping';
+  [serviceCapabilities] = ['@libp2p/ping'];
+  async start() {
+    await this.components.registrar.handle(this.protocol, this.handleMessage, {
+      maxInboundStreams: this.maxInboundStreams,
+      maxOutboundStreams: this.maxOutboundStreams,
+      runOnLimitedConnection: this.runOnLimitedConnection
+    });
+    this.started = true;
+  }
+  async stop() {
+    await this.components.registrar.unhandle(this.protocol);
+    this.started = false;
+  }
+  isStarted() {
+    return this.started;
+  }
+  /**
+   * A handler to register with Libp2p to process ping messages
+   */
+  handleMessage(data) {
+    this.log('incoming ping from %p', data.connection.remotePeer);
+    const {
+      stream
+    } = data;
+    const start = Date.now();
+    const bytes = byteStream(stream);
+    let pinged = false;
+    Promise.resolve().then(async () => {
+      while (true) {
+        const signal = AbortSignal.timeout(this.timeout);
+        setMaxListeners(Infinity, signal);
+        signal.addEventListener('abort', () => {
+          stream?.abort(new TimeoutError('ping timeout'));
+        });
+        const buf = await bytes.read({
+          bytes: PING_LENGTH,
+          signal
+        });
+        await bytes.write(buf, {
+          signal
+        });
+        pinged = true;
+      }
+    }).catch(err => {
+      // ignore the error if we've processed at least one ping, the remote
+      // closed the stream and we handled or are handling the close cleanly
+      if (pinged && err.name === 'UnexpectedEOFError' && stream.readStatus !== 'ready') {
+        return;
+      }
+      this.log.error('incoming ping from %p failed with error - %e', data.connection.remotePeer, err);
+      stream?.abort(err);
+    }).finally(() => {
+      const ms = Date.now() - start;
+      this.log('incoming ping from %p complete in %dms', data.connection.remotePeer, ms);
+      const signal = AbortSignal.timeout(this.timeout);
+      setMaxListeners(Infinity, signal);
+      stream.close({
+        signal
+      }).catch(err => {
+        this.log.error('error closing ping stream from %p - %e', data.connection.remotePeer, err);
+        stream?.abort(err);
+      });
+    });
+  }
+  /**
+   * Ping a given peer and wait for its response, getting the operation latency.
+   */
+  async ping(peer) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    this.log('pinging %p', peer);
+    const start = Date.now();
+    const data = randomBytes(PING_LENGTH);
+    const connection = await this.components.connectionManager.openConnection(peer, options);
+    let stream;
+    if (options.signal == null) {
+      const signal = AbortSignal.timeout(this.timeout);
+      options = {
+        ...options,
+        signal
+      };
+    }
+    try {
+      stream = await connection.newStream(this.protocol, {
+        ...options,
+        runOnLimitedConnection: this.runOnLimitedConnection
+      });
+      const bytes = byteStream(stream);
+      const [, result] = await Promise.all([bytes.write(data, options), bytes.read({
+        ...options,
+        bytes: PING_LENGTH
+      })]);
+      const ms = Date.now() - start;
+      if (!equals(data, result.subarray())) {
+        throw new ProtocolError(`Received wrong ping ack after ${ms}ms`);
+      }
+      this.log('ping %p complete in %dms', connection.remotePeer, ms);
+      return ms;
+    } catch (err) {
+      this.log.error('error while pinging %p', connection.remotePeer, err);
+      stream?.abort(err);
+      throw err;
+    } finally {
+      if (stream != null) {
+        await stream.close(options);
+      }
+    }
+  }
+}
+
+export { Ping };