@libp2p/peer-record 0.0.0

package/src/peer-record/index.ts

@@ -0,0 +1,104 @@
+import { Multiaddr } from '@multiformats/multiaddr'
+import { PeerId } from '@libp2p/peer-id'
+import { arrayEquals } from '@libp2p/utils/array-equals'
+import { PeerRecord as Protobuf } from './peer-record.js'
+import {
+  ENVELOPE_DOMAIN_PEER_RECORD,
+  ENVELOPE_PAYLOAD_TYPE_PEER_RECORD
+} from './consts.js'
+
+export interface PeerRecordOptions {
+  peerId: PeerId
+
+  /**
+   * Addresses of the associated peer.
+   */
+  multiaddrs?: Multiaddr[]
+
+  /**
+   * Monotonically-increasing sequence counter that's used to order PeerRecords in time.
+   */
+  seqNumber?: number
+}
+
+/**
+ * The PeerRecord is used for distributing peer routing records across the network.
+ * It contains the peer's reachable listen addresses.
+ */
+export class PeerRecord {
+  /**
+   * Unmarshal Peer Record Protobuf.
+   *
+   * @param {Uint8Array} buf - marshaled peer record.
+   * @returns {PeerRecord}
+   */
+  static createFromProtobuf = (buf: Uint8Array) => {
+    const peerRecord = Protobuf.decode(buf)
+    const peerId = PeerId.fromBytes(peerRecord.peerId)
+    const multiaddrs = (peerRecord.addresses || []).map((a) => new Multiaddr(a.multiaddr))
+    const seqNumber = Number(peerRecord.seq)
+
+    return new PeerRecord({ peerId, multiaddrs, seqNumber })
+  }
+
+  static DOMAIN = ENVELOPE_DOMAIN_PEER_RECORD
+  static CODEC = ENVELOPE_PAYLOAD_TYPE_PEER_RECORD
+
+  public peerId: PeerId
+  public multiaddrs: Multiaddr[]
+  public seqNumber: number
+  public domain = PeerRecord.DOMAIN
+  public codec = PeerRecord.CODEC
+  private marshaled?: Uint8Array
+
+  constructor (options: PeerRecordOptions) {
+    const { peerId, multiaddrs, seqNumber } = options
+
+    this.peerId = peerId
+    this.multiaddrs = multiaddrs ?? []
+    this.seqNumber = seqNumber ?? Date.now()
+  }
+
+  /**
+   * Marshal a record to be used in an envelope
+   */
+  marshal () {
+    if (this.marshaled == null) {
+      this.marshaled = Protobuf.encode({
+        peerId: this.peerId.toBytes(),
+        seq: this.seqNumber,
+        addresses: this.multiaddrs.map((m) => ({
+          multiaddr: m.bytes
+        }))
+      }).finish()
+    }
+
+    return this.marshaled
+  }
+
+  /**
+   * Returns true if `this` record equals the `other`
+   */
+  equals (other: unknown) {
+    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
+  }
+}

package/src/peer-record/peer-record.d.ts

@@ -0,0 +1,133 @@
+import * as $protobuf from "protobufjs";
+/** Properties of a PeerRecord. */
+export interface IPeerRecord {
+
+    /** PeerRecord peerId */
+    peerId?: (Uint8Array|null);
+
+    /** PeerRecord seq */
+    seq?: (number|null);
+
+    /** PeerRecord addresses */
+    addresses?: (PeerRecord.IAddressInfo[]|null);
+}
+
+/** Represents a PeerRecord. */
+export class PeerRecord implements IPeerRecord {
+
+    /**
+     * Constructs a new PeerRecord.
+     * @param [p] Properties to set
+     */
+    constructor(p?: IPeerRecord);
+
+    /** PeerRecord peerId. */
+    public peerId: Uint8Array;
+
+    /** PeerRecord seq. */
+    public seq: number;
+
+    /** PeerRecord addresses. */
+    public addresses: PeerRecord.IAddressInfo[];
+
+    /**
+     * Encodes the specified PeerRecord message. Does not implicitly {@link PeerRecord.verify|verify} messages.
+     * @param m PeerRecord message or plain object to encode
+     * @param [w] Writer to encode to
+     * @returns Writer
+     */
+    public static encode(m: IPeerRecord, w?: $protobuf.Writer): $protobuf.Writer;
+
+    /**
+     * Decodes a PeerRecord message from the specified reader or buffer.
+     * @param r Reader or buffer to decode from
+     * @param [l] Message length if known beforehand
+     * @returns PeerRecord
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): PeerRecord;
+
+    /**
+     * Creates a PeerRecord message from a plain object. Also converts values to their respective internal types.
+     * @param d Plain object
+     * @returns PeerRecord
+     */
+    public static fromObject(d: { [k: string]: any }): PeerRecord;
+
+    /**
+     * Creates a plain object from a PeerRecord message. Also converts values to other types if specified.
+     * @param m PeerRecord
+     * @param [o] Conversion options
+     * @returns Plain object
+     */
+    public static toObject(m: PeerRecord, o?: $protobuf.IConversionOptions): { [k: string]: any };
+
+    /**
+     * Converts this PeerRecord to JSON.
+     * @returns JSON object
+     */
+    public toJSON(): { [k: string]: any };
+}
+
+export namespace PeerRecord {
+
+    /** Properties of an AddressInfo. */
+    interface IAddressInfo {
+
+        /** AddressInfo multiaddr */
+        multiaddr?: (Uint8Array|null);
+    }
+
+    /** Represents an AddressInfo. */
+    class AddressInfo implements IAddressInfo {
+
+        /**
+         * Constructs a new AddressInfo.
+         * @param [p] Properties to set
+         */
+        constructor(p?: PeerRecord.IAddressInfo);
+
+        /** AddressInfo multiaddr. */
+        public multiaddr: Uint8Array;
+
+        /**
+         * Encodes the specified AddressInfo message. Does not implicitly {@link PeerRecord.AddressInfo.verify|verify} messages.
+         * @param m AddressInfo message or plain object to encode
+         * @param [w] Writer to encode to
+         * @returns Writer
+         */
+        public static encode(m: PeerRecord.IAddressInfo, w?: $protobuf.Writer): $protobuf.Writer;
+
+        /**
+         * Decodes an AddressInfo message from the specified reader or buffer.
+         * @param r Reader or buffer to decode from
+         * @param [l] Message length if known beforehand
+         * @returns AddressInfo
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): PeerRecord.AddressInfo;
+
+        /**
+         * Creates an AddressInfo message from a plain object. Also converts values to their respective internal types.
+         * @param d Plain object
+         * @returns AddressInfo
+         */
+        public static fromObject(d: { [k: string]: any }): PeerRecord.AddressInfo;
+
+        /**
+         * Creates a plain object from an AddressInfo message. Also converts values to other types if specified.
+         * @param m AddressInfo
+         * @param [o] Conversion options
+         * @returns Plain object
+         */
+        public static toObject(m: PeerRecord.AddressInfo, o?: $protobuf.IConversionOptions): { [k: string]: any };
+
+        /**
+         * Converts this AddressInfo to JSON.
+         * @returns JSON object
+         */
+        public toJSON(): { [k: string]: any };
+    }
+}

package/src/peer-record/peer-record.js

@@ -0,0 +1,365 @@
+/*eslint-disable*/
+import $protobuf from "protobufjs/minimal.js";
+
+// Common aliases
+const $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;
+
+// Exported root namespace
+const $root = $protobuf.roots["libp2p-peer-record"] || ($protobuf.roots["libp2p-peer-record"] = {});
+
+export const PeerRecord = $root.PeerRecord = (() => {
+
+    /**
+     * Properties of a PeerRecord.
+     * @exports IPeerRecord
+     * @interface IPeerRecord
+     * @property {Uint8Array|null} [peerId] PeerRecord peerId
+     * @property {number|null} [seq] PeerRecord seq
+     * @property {Array.<PeerRecord.IAddressInfo>|null} [addresses] PeerRecord addresses
+     */
+
+    /**
+     * Constructs a new PeerRecord.
+     * @exports PeerRecord
+     * @classdesc Represents a PeerRecord.
+     * @implements IPeerRecord
+     * @constructor
+     * @param {IPeerRecord=} [p] Properties to set
+     */
+    function PeerRecord(p) {
+        this.addresses = [];
+        if (p)
+            for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
+                if (p[ks[i]] != null)
+                    this[ks[i]] = p[ks[i]];
+    }
+
+    /**
+     * PeerRecord peerId.
+     * @member {Uint8Array} peerId
+     * @memberof PeerRecord
+     * @instance
+     */
+    PeerRecord.prototype.peerId = $util.newBuffer([]);
+
+    /**
+     * PeerRecord seq.
+     * @member {number} seq
+     * @memberof PeerRecord
+     * @instance
+     */
+    PeerRecord.prototype.seq = $util.Long ? $util.Long.fromBits(0,0,true) : 0;
+
+    /**
+     * PeerRecord addresses.
+     * @member {Array.<PeerRecord.IAddressInfo>} addresses
+     * @memberof PeerRecord
+     * @instance
+     */
+    PeerRecord.prototype.addresses = $util.emptyArray;
+
+    /**
+     * Encodes the specified PeerRecord message. Does not implicitly {@link PeerRecord.verify|verify} messages.
+     * @function encode
+     * @memberof PeerRecord
+     * @static
+     * @param {IPeerRecord} m PeerRecord message or plain object to encode
+     * @param {$protobuf.Writer} [w] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    PeerRecord.encode = function encode(m, w) {
+        if (!w)
+            w = $Writer.create();
+        if (m.peerId != null && Object.hasOwnProperty.call(m, "peerId"))
+            w.uint32(10).bytes(m.peerId);
+        if (m.seq != null && Object.hasOwnProperty.call(m, "seq"))
+            w.uint32(16).uint64(m.seq);
+        if (m.addresses != null && m.addresses.length) {
+            for (var i = 0; i < m.addresses.length; ++i)
+                $root.PeerRecord.AddressInfo.encode(m.addresses[i], w.uint32(26).fork()).ldelim();
+        }
+        return w;
+    };
+
+    /**
+     * Decodes a PeerRecord message from the specified reader or buffer.
+     * @function decode
+     * @memberof PeerRecord
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
+     * @param {number} [l] Message length if known beforehand
+     * @returns {PeerRecord} PeerRecord
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    PeerRecord.decode = function decode(r, l) {
+        if (!(r instanceof $Reader))
+            r = $Reader.create(r);
+        var c = l === undefined ? r.len : r.pos + l, m = new $root.PeerRecord();
+        while (r.pos < c) {
+            var t = r.uint32();
+            switch (t >>> 3) {
+            case 1:
+                m.peerId = r.bytes();
+                break;
+            case 2:
+                m.seq = r.uint64();
+                break;
+            case 3:
+                if (!(m.addresses && m.addresses.length))
+                    m.addresses = [];
+                m.addresses.push($root.PeerRecord.AddressInfo.decode(r, r.uint32()));
+                break;
+            default:
+                r.skipType(t & 7);
+                break;
+            }
+        }
+        return m;
+    };
+
+    /**
+     * Creates a PeerRecord message from a plain object. Also converts values to their respective internal types.
+     * @function fromObject
+     * @memberof PeerRecord
+     * @static
+     * @param {Object.<string,*>} d Plain object
+     * @returns {PeerRecord} PeerRecord
+     */
+    PeerRecord.fromObject = function fromObject(d) {
+        if (d instanceof $root.PeerRecord)
+            return d;
+        var m = new $root.PeerRecord();
+        if (d.peerId != null) {
+            if (typeof d.peerId === "string")
+                $util.base64.decode(d.peerId, m.peerId = $util.newBuffer($util.base64.length(d.peerId)), 0);
+            else if (d.peerId.length)
+                m.peerId = d.peerId;
+        }
+        if (d.seq != null) {
+            if ($util.Long)
+                (m.seq = $util.Long.fromValue(d.seq)).unsigned = true;
+            else if (typeof d.seq === "string")
+                m.seq = parseInt(d.seq, 10);
+            else if (typeof d.seq === "number")
+                m.seq = d.seq;
+            else if (typeof d.seq === "object")
+                m.seq = new $util.LongBits(d.seq.low >>> 0, d.seq.high >>> 0).toNumber(true);
+        }
+        if (d.addresses) {
+            if (!Array.isArray(d.addresses))
+                throw TypeError(".PeerRecord.addresses: array expected");
+            m.addresses = [];
+            for (var i = 0; i < d.addresses.length; ++i) {
+                if (typeof d.addresses[i] !== "object")
+                    throw TypeError(".PeerRecord.addresses: object expected");
+                m.addresses[i] = $root.PeerRecord.AddressInfo.fromObject(d.addresses[i]);
+            }
+        }
+        return m;
+    };
+
+    /**
+     * Creates a plain object from a PeerRecord message. Also converts values to other types if specified.
+     * @function toObject
+     * @memberof PeerRecord
+     * @static
+     * @param {PeerRecord} m PeerRecord
+     * @param {$protobuf.IConversionOptions} [o] Conversion options
+     * @returns {Object.<string,*>} Plain object
+     */
+    PeerRecord.toObject = function toObject(m, o) {
+        if (!o)
+            o = {};
+        var d = {};
+        if (o.arrays || o.defaults) {
+            d.addresses = [];
+        }
+        if (o.defaults) {
+            if (o.bytes === String)
+                d.peerId = "";
+            else {
+                d.peerId = [];
+                if (o.bytes !== Array)
+                    d.peerId = $util.newBuffer(d.peerId);
+            }
+            if ($util.Long) {
+                var n = new $util.Long(0, 0, true);
+                d.seq = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n;
+            } else
+                d.seq = o.longs === String ? "0" : 0;
+        }
+        if (m.peerId != null && m.hasOwnProperty("peerId")) {
+            d.peerId = o.bytes === String ? $util.base64.encode(m.peerId, 0, m.peerId.length) : o.bytes === Array ? Array.prototype.slice.call(m.peerId) : m.peerId;
+        }
+        if (m.seq != null && m.hasOwnProperty("seq")) {
+            if (typeof m.seq === "number")
+                d.seq = o.longs === String ? String(m.seq) : m.seq;
+            else
+                d.seq = o.longs === String ? $util.Long.prototype.toString.call(m.seq) : o.longs === Number ? new $util.LongBits(m.seq.low >>> 0, m.seq.high >>> 0).toNumber(true) : m.seq;
+        }
+        if (m.addresses && m.addresses.length) {
+            d.addresses = [];
+            for (var j = 0; j < m.addresses.length; ++j) {
+                d.addresses[j] = $root.PeerRecord.AddressInfo.toObject(m.addresses[j], o);
+            }
+        }
+        return d;
+    };
+
+    /**
+     * Converts this PeerRecord to JSON.
+     * @function toJSON
+     * @memberof PeerRecord
+     * @instance
+     * @returns {Object.<string,*>} JSON object
+     */
+    PeerRecord.prototype.toJSON = function toJSON() {
+        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+    };
+
+    PeerRecord.AddressInfo = (function() {
+
+        /**
+         * Properties of an AddressInfo.
+         * @memberof PeerRecord
+         * @interface IAddressInfo
+         * @property {Uint8Array|null} [multiaddr] AddressInfo multiaddr
+         */
+
+        /**
+         * Constructs a new AddressInfo.
+         * @memberof PeerRecord
+         * @classdesc Represents an AddressInfo.
+         * @implements IAddressInfo
+         * @constructor
+         * @param {PeerRecord.IAddressInfo=} [p] Properties to set
+         */
+        function AddressInfo(p) {
+            if (p)
+                for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
+                    if (p[ks[i]] != null)
+                        this[ks[i]] = p[ks[i]];
+        }
+
+        /**
+         * AddressInfo multiaddr.
+         * @member {Uint8Array} multiaddr
+         * @memberof PeerRecord.AddressInfo
+         * @instance
+         */
+        AddressInfo.prototype.multiaddr = $util.newBuffer([]);
+
+        /**
+         * Encodes the specified AddressInfo message. Does not implicitly {@link PeerRecord.AddressInfo.verify|verify} messages.
+         * @function encode
+         * @memberof PeerRecord.AddressInfo
+         * @static
+         * @param {PeerRecord.IAddressInfo} m AddressInfo message or plain object to encode
+         * @param {$protobuf.Writer} [w] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        AddressInfo.encode = function encode(m, w) {
+            if (!w)
+                w = $Writer.create();
+            if (m.multiaddr != null && Object.hasOwnProperty.call(m, "multiaddr"))
+                w.uint32(10).bytes(m.multiaddr);
+            return w;
+        };
+
+        /**
+         * Decodes an AddressInfo message from the specified reader or buffer.
+         * @function decode
+         * @memberof PeerRecord.AddressInfo
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
+         * @param {number} [l] Message length if known beforehand
+         * @returns {PeerRecord.AddressInfo} AddressInfo
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        AddressInfo.decode = function decode(r, l) {
+            if (!(r instanceof $Reader))
+                r = $Reader.create(r);
+            var c = l === undefined ? r.len : r.pos + l, m = new $root.PeerRecord.AddressInfo();
+            while (r.pos < c) {
+                var t = r.uint32();
+                switch (t >>> 3) {
+                case 1:
+                    m.multiaddr = r.bytes();
+                    break;
+                default:
+                    r.skipType(t & 7);
+                    break;
+                }
+            }
+            return m;
+        };
+
+        /**
+         * Creates an AddressInfo message from a plain object. Also converts values to their respective internal types.
+         * @function fromObject
+         * @memberof PeerRecord.AddressInfo
+         * @static
+         * @param {Object.<string,*>} d Plain object
+         * @returns {PeerRecord.AddressInfo} AddressInfo
+         */
+        AddressInfo.fromObject = function fromObject(d) {
+            if (d instanceof $root.PeerRecord.AddressInfo)
+                return d;
+            var m = new $root.PeerRecord.AddressInfo();
+            if (d.multiaddr != null) {
+                if (typeof d.multiaddr === "string")
+                    $util.base64.decode(d.multiaddr, m.multiaddr = $util.newBuffer($util.base64.length(d.multiaddr)), 0);
+                else if (d.multiaddr.length)
+                    m.multiaddr = d.multiaddr;
+            }
+            return m;
+        };
+
+        /**
+         * Creates a plain object from an AddressInfo message. Also converts values to other types if specified.
+         * @function toObject
+         * @memberof PeerRecord.AddressInfo
+         * @static
+         * @param {PeerRecord.AddressInfo} m AddressInfo
+         * @param {$protobuf.IConversionOptions} [o] Conversion options
+         * @returns {Object.<string,*>} Plain object
+         */
+        AddressInfo.toObject = function toObject(m, o) {
+            if (!o)
+                o = {};
+            var d = {};
+            if (o.defaults) {
+                if (o.bytes === String)
+                    d.multiaddr = "";
+                else {
+                    d.multiaddr = [];
+                    if (o.bytes !== Array)
+                        d.multiaddr = $util.newBuffer(d.multiaddr);
+                }
+            }
+            if (m.multiaddr != null && m.hasOwnProperty("multiaddr")) {
+                d.multiaddr = o.bytes === String ? $util.base64.encode(m.multiaddr, 0, m.multiaddr.length) : o.bytes === Array ? Array.prototype.slice.call(m.multiaddr) : m.multiaddr;
+            }
+            return d;
+        };
+
+        /**
+         * Converts this AddressInfo to JSON.
+         * @function toJSON
+         * @memberof PeerRecord.AddressInfo
+         * @instance
+         * @returns {Object.<string,*>} JSON object
+         */
+        AddressInfo.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+
+        return AddressInfo;
+    })();
+
+    return PeerRecord;
+})();
+
+export { $root as default };

package/src/peer-record/peer-record.proto

@@ -0,0 +1,18 @@
+syntax = "proto3";
+
+message PeerRecord {
+    // AddressInfo is a wrapper around a binary multiaddr. It is defined as a
+    // separate message to allow us to add per-address metadata in the future.
+    message AddressInfo {
+        bytes multiaddr = 1;
+    }
+
+    // peer_id contains a libp2p peer id in its binary representation.
+    bytes peer_id = 1;
+
+    // seq contains a monotonically-increasing sequence counter to order PeerRecords in time.
+    uint64 seq = 2;
+
+    // addresses is a list of public listen addresses for the peer.
+    repeated AddressInfo addresses = 3;
+}