libp2p 0.36.0 → 0.36.2-199395d

package/src/identify/pb/message.js

@@ -0,0 +1,369 @@
+/*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-identify"] || ($protobuf.roots["libp2p-identify"] = {});
+
+export const Identify = $root.Identify = (() => {
+
+    /**
+     * Properties of an Identify.
+     * @exports IIdentify
+     * @interface IIdentify
+     * @property {string|null} [protocolVersion] Identify protocolVersion
+     * @property {string|null} [agentVersion] Identify agentVersion
+     * @property {Uint8Array|null} [publicKey] Identify publicKey
+     * @property {Array.<Uint8Array>|null} [listenAddrs] Identify listenAddrs
+     * @property {Uint8Array|null} [observedAddr] Identify observedAddr
+     * @property {Array.<string>|null} [protocols] Identify protocols
+     * @property {Uint8Array|null} [signedPeerRecord] Identify signedPeerRecord
+     */
+
+    /**
+     * Constructs a new Identify.
+     * @exports Identify
+     * @classdesc Represents an Identify.
+     * @implements IIdentify
+     * @constructor
+     * @param {IIdentify=} [p] Properties to set
+     */
+    function Identify(p) {
+        this.listenAddrs = [];
+        this.protocols = [];
+        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]];
+    }
+
+    /**
+     * Identify protocolVersion.
+     * @member {string|null|undefined} protocolVersion
+     * @memberof Identify
+     * @instance
+     */
+    Identify.prototype.protocolVersion = null;
+
+    /**
+     * Identify agentVersion.
+     * @member {string|null|undefined} agentVersion
+     * @memberof Identify
+     * @instance
+     */
+    Identify.prototype.agentVersion = null;
+
+    /**
+     * Identify publicKey.
+     * @member {Uint8Array|null|undefined} publicKey
+     * @memberof Identify
+     * @instance
+     */
+    Identify.prototype.publicKey = null;
+
+    /**
+     * Identify listenAddrs.
+     * @member {Array.<Uint8Array>} listenAddrs
+     * @memberof Identify
+     * @instance
+     */
+    Identify.prototype.listenAddrs = $util.emptyArray;
+
+    /**
+     * Identify observedAddr.
+     * @member {Uint8Array|null|undefined} observedAddr
+     * @memberof Identify
+     * @instance
+     */
+    Identify.prototype.observedAddr = null;
+
+    /**
+     * Identify protocols.
+     * @member {Array.<string>} protocols
+     * @memberof Identify
+     * @instance
+     */
+    Identify.prototype.protocols = $util.emptyArray;
+
+    /**
+     * Identify signedPeerRecord.
+     * @member {Uint8Array|null|undefined} signedPeerRecord
+     * @memberof Identify
+     * @instance
+     */
+    Identify.prototype.signedPeerRecord = null;
+
+    // OneOf field names bound to virtual getters and setters
+    let $oneOfFields;
+
+    /**
+     * Identify _protocolVersion.
+     * @member {"protocolVersion"|undefined} _protocolVersion
+     * @memberof Identify
+     * @instance
+     */
+    Object.defineProperty(Identify.prototype, "_protocolVersion", {
+        get: $util.oneOfGetter($oneOfFields = ["protocolVersion"]),
+        set: $util.oneOfSetter($oneOfFields)
+    });
+
+    /**
+     * Identify _agentVersion.
+     * @member {"agentVersion"|undefined} _agentVersion
+     * @memberof Identify
+     * @instance
+     */
+    Object.defineProperty(Identify.prototype, "_agentVersion", {
+        get: $util.oneOfGetter($oneOfFields = ["agentVersion"]),
+        set: $util.oneOfSetter($oneOfFields)
+    });
+
+    /**
+     * Identify _publicKey.
+     * @member {"publicKey"|undefined} _publicKey
+     * @memberof Identify
+     * @instance
+     */
+    Object.defineProperty(Identify.prototype, "_publicKey", {
+        get: $util.oneOfGetter($oneOfFields = ["publicKey"]),
+        set: $util.oneOfSetter($oneOfFields)
+    });
+
+    /**
+     * Identify _observedAddr.
+     * @member {"observedAddr"|undefined} _observedAddr
+     * @memberof Identify
+     * @instance
+     */
+    Object.defineProperty(Identify.prototype, "_observedAddr", {
+        get: $util.oneOfGetter($oneOfFields = ["observedAddr"]),
+        set: $util.oneOfSetter($oneOfFields)
+    });
+
+    /**
+     * Identify _signedPeerRecord.
+     * @member {"signedPeerRecord"|undefined} _signedPeerRecord
+     * @memberof Identify
+     * @instance
+     */
+    Object.defineProperty(Identify.prototype, "_signedPeerRecord", {
+        get: $util.oneOfGetter($oneOfFields = ["signedPeerRecord"]),
+        set: $util.oneOfSetter($oneOfFields)
+    });
+
+    /**
+     * Encodes the specified Identify message. Does not implicitly {@link Identify.verify|verify} messages.
+     * @function encode
+     * @memberof Identify
+     * @static
+     * @param {IIdentify} m Identify message or plain object to encode
+     * @param {$protobuf.Writer} [w] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    Identify.encode = function encode(m, w) {
+        if (!w)
+            w = $Writer.create();
+        if (m.publicKey != null && Object.hasOwnProperty.call(m, "publicKey"))
+            w.uint32(10).bytes(m.publicKey);
+        if (m.listenAddrs != null && m.listenAddrs.length) {
+            for (var i = 0; i < m.listenAddrs.length; ++i)
+                w.uint32(18).bytes(m.listenAddrs[i]);
+        }
+        if (m.protocols != null && m.protocols.length) {
+            for (var i = 0; i < m.protocols.length; ++i)
+                w.uint32(26).string(m.protocols[i]);
+        }
+        if (m.observedAddr != null && Object.hasOwnProperty.call(m, "observedAddr"))
+            w.uint32(34).bytes(m.observedAddr);
+        if (m.protocolVersion != null && Object.hasOwnProperty.call(m, "protocolVersion"))
+            w.uint32(42).string(m.protocolVersion);
+        if (m.agentVersion != null && Object.hasOwnProperty.call(m, "agentVersion"))
+            w.uint32(50).string(m.agentVersion);
+        if (m.signedPeerRecord != null && Object.hasOwnProperty.call(m, "signedPeerRecord"))
+            w.uint32(66).bytes(m.signedPeerRecord);
+        return w;
+    };
+
+    /**
+     * Decodes an Identify message from the specified reader or buffer.
+     * @function decode
+     * @memberof Identify
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
+     * @param {number} [l] Message length if known beforehand
+     * @returns {Identify} Identify
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    Identify.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.Identify();
+        while (r.pos < c) {
+            var t = r.uint32();
+            switch (t >>> 3) {
+            case 5:
+                m.protocolVersion = r.string();
+                break;
+            case 6:
+                m.agentVersion = r.string();
+                break;
+            case 1:
+                m.publicKey = r.bytes();
+                break;
+            case 2:
+                if (!(m.listenAddrs && m.listenAddrs.length))
+                    m.listenAddrs = [];
+                m.listenAddrs.push(r.bytes());
+                break;
+            case 4:
+                m.observedAddr = r.bytes();
+                break;
+            case 3:
+                if (!(m.protocols && m.protocols.length))
+                    m.protocols = [];
+                m.protocols.push(r.string());
+                break;
+            case 8:
+                m.signedPeerRecord = r.bytes();
+                break;
+            default:
+                r.skipType(t & 7);
+                break;
+            }
+        }
+        return m;
+    };
+
+    /**
+     * Creates an Identify message from a plain object. Also converts values to their respective internal types.
+     * @function fromObject
+     * @memberof Identify
+     * @static
+     * @param {Object.<string,*>} d Plain object
+     * @returns {Identify} Identify
+     */
+    Identify.fromObject = function fromObject(d) {
+        if (d instanceof $root.Identify)
+            return d;
+        var m = new $root.Identify();
+        if (d.protocolVersion != null) {
+            m.protocolVersion = String(d.protocolVersion);
+        }
+        if (d.agentVersion != null) {
+            m.agentVersion = String(d.agentVersion);
+        }
+        if (d.publicKey != null) {
+            if (typeof d.publicKey === "string")
+                $util.base64.decode(d.publicKey, m.publicKey = $util.newBuffer($util.base64.length(d.publicKey)), 0);
+            else if (d.publicKey.length)
+                m.publicKey = d.publicKey;
+        }
+        if (d.listenAddrs) {
+            if (!Array.isArray(d.listenAddrs))
+                throw TypeError(".Identify.listenAddrs: array expected");
+            m.listenAddrs = [];
+            for (var i = 0; i < d.listenAddrs.length; ++i) {
+                if (typeof d.listenAddrs[i] === "string")
+                    $util.base64.decode(d.listenAddrs[i], m.listenAddrs[i] = $util.newBuffer($util.base64.length(d.listenAddrs[i])), 0);
+                else if (d.listenAddrs[i].length)
+                    m.listenAddrs[i] = d.listenAddrs[i];
+            }
+        }
+        if (d.observedAddr != null) {
+            if (typeof d.observedAddr === "string")
+                $util.base64.decode(d.observedAddr, m.observedAddr = $util.newBuffer($util.base64.length(d.observedAddr)), 0);
+            else if (d.observedAddr.length)
+                m.observedAddr = d.observedAddr;
+        }
+        if (d.protocols) {
+            if (!Array.isArray(d.protocols))
+                throw TypeError(".Identify.protocols: array expected");
+            m.protocols = [];
+            for (var i = 0; i < d.protocols.length; ++i) {
+                m.protocols[i] = String(d.protocols[i]);
+            }
+        }
+        if (d.signedPeerRecord != null) {
+            if (typeof d.signedPeerRecord === "string")
+                $util.base64.decode(d.signedPeerRecord, m.signedPeerRecord = $util.newBuffer($util.base64.length(d.signedPeerRecord)), 0);
+            else if (d.signedPeerRecord.length)
+                m.signedPeerRecord = d.signedPeerRecord;
+        }
+        return m;
+    };
+
+    /**
+     * Creates a plain object from an Identify message. Also converts values to other types if specified.
+     * @function toObject
+     * @memberof Identify
+     * @static
+     * @param {Identify} m Identify
+     * @param {$protobuf.IConversionOptions} [o] Conversion options
+     * @returns {Object.<string,*>} Plain object
+     */
+    Identify.toObject = function toObject(m, o) {
+        if (!o)
+            o = {};
+        var d = {};
+        if (o.arrays || o.defaults) {
+            d.listenAddrs = [];
+            d.protocols = [];
+        }
+        if (m.publicKey != null && m.hasOwnProperty("publicKey")) {
+            d.publicKey = o.bytes === String ? $util.base64.encode(m.publicKey, 0, m.publicKey.length) : o.bytes === Array ? Array.prototype.slice.call(m.publicKey) : m.publicKey;
+            if (o.oneofs)
+                d._publicKey = "publicKey";
+        }
+        if (m.listenAddrs && m.listenAddrs.length) {
+            d.listenAddrs = [];
+            for (var j = 0; j < m.listenAddrs.length; ++j) {
+                d.listenAddrs[j] = o.bytes === String ? $util.base64.encode(m.listenAddrs[j], 0, m.listenAddrs[j].length) : o.bytes === Array ? Array.prototype.slice.call(m.listenAddrs[j]) : m.listenAddrs[j];
+            }
+        }
+        if (m.protocols && m.protocols.length) {
+            d.protocols = [];
+            for (var j = 0; j < m.protocols.length; ++j) {
+                d.protocols[j] = m.protocols[j];
+            }
+        }
+        if (m.observedAddr != null && m.hasOwnProperty("observedAddr")) {
+            d.observedAddr = o.bytes === String ? $util.base64.encode(m.observedAddr, 0, m.observedAddr.length) : o.bytes === Array ? Array.prototype.slice.call(m.observedAddr) : m.observedAddr;
+            if (o.oneofs)
+                d._observedAddr = "observedAddr";
+        }
+        if (m.protocolVersion != null && m.hasOwnProperty("protocolVersion")) {
+            d.protocolVersion = m.protocolVersion;
+            if (o.oneofs)
+                d._protocolVersion = "protocolVersion";
+        }
+        if (m.agentVersion != null && m.hasOwnProperty("agentVersion")) {
+            d.agentVersion = m.agentVersion;
+            if (o.oneofs)
+                d._agentVersion = "agentVersion";
+        }
+        if (m.signedPeerRecord != null && m.hasOwnProperty("signedPeerRecord")) {
+            d.signedPeerRecord = o.bytes === String ? $util.base64.encode(m.signedPeerRecord, 0, m.signedPeerRecord.length) : o.bytes === Array ? Array.prototype.slice.call(m.signedPeerRecord) : m.signedPeerRecord;
+            if (o.oneofs)
+                d._signedPeerRecord = "signedPeerRecord";
+        }
+        return d;
+    };
+
+    /**
+     * Converts this Identify to JSON.
+     * @function toJSON
+     * @memberof Identify
+     * @instance
+     * @returns {Object.<string,*>} JSON object
+     */
+    Identify.prototype.toJSON = function toJSON() {
+        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+    };
+
+    return Identify;
+})();
+
+export { $root as default };

package/src/index.ts

@@ -0,0 +1,234 @@
+import { createLibp2pNode } from './libp2p.js'
+import type { AbortOptions, EventEmitter, RecursivePartial, Startable } from '@libp2p/interfaces'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { FAULT_TOLERANCE } from './transport-manager.js'
+import type { HostProperties } from './identify/index.js'
+import type { DualDHT } from '@libp2p/interfaces/dht'
+import type { Datastore } from 'interface-datastore'
+import type { PeerStore, PeerStoreInit } from '@libp2p/interfaces/peer-store'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { AutoRelayConfig, RelayAdvertiseConfig } from './circuit/index.js'
+import type { PeerDiscovery } from '@libp2p/interfaces/peer-discovery'
+import type { Connection, ConnectionGater, ConnectionProtector, ProtocolStream } from '@libp2p/interfaces/connection'
+import type { Transport } from '@libp2p/interfaces/transport'
+import type { StreamMuxerFactory } from '@libp2p/interfaces/stream-muxer'
+import type { ConnectionEncrypter } from '@libp2p/interfaces/connection-encrypter'
+import type { PeerRouting } from '@libp2p/interfaces/peer-routing'
+import type { ContentRouting } from '@libp2p/interfaces/content-routing'
+import type { PubSub } from '@libp2p/interfaces/pubsub'
+import type { ConnectionManager, StreamHandler } from '@libp2p/interfaces/registrar'
+import type { MetricsInit } from '@libp2p/interfaces/metrics'
+import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import type { DialerInit } from '@libp2p/interfaces/dialer'
+import type { KeyChain } from './keychain/index.js'
+
+export interface PersistentPeerStoreOptions {
+  threshold?: number
+}
+
+export interface DEKConfig {
+  keyLength: number
+  iterationCount: number
+  salt: string
+  hash: string
+}
+
+export interface KeychainConfig {
+  pass?: string
+  dek?: DEKConfig
+}
+
+export interface MetricsConfig {
+  enabled?: boolean
+}
+
+export interface HopConfig {
+  enabled?: boolean
+  active?: boolean
+}
+
+export interface RelayConfig {
+  enabled: boolean
+  advertise: RelayAdvertiseConfig
+  hop: HopConfig
+  autoRelay: AutoRelayConfig
+}
+
+export interface NatManagerConfig {
+  enabled: boolean
+  externalAddress?: string
+  localAddress?: string
+  description?: string
+  ttl?: number
+  keepAlive: boolean
+  gateway?: string
+}
+
+export interface AddressesConfig {
+  listen: string[]
+  announce: string[]
+  noAnnounce: string[]
+  announceFilter: (multiaddrs: Multiaddr[]) => Multiaddr[]
+}
+
+export interface ConnectionManagerConfig {
+  /**
+   * If true, try to connect to all discovered peers up to the connection manager limit
+   */
+  autoDial?: boolean
+
+  /**
+   * The maximum number of connections to keep open
+   */
+  maxConnections: number
+
+  /**
+   * The minimum number of connections to keep open
+   */
+  minConnections: number
+
+  /**
+   * How long to wait between attempting to keep our number of concurrent connections
+   * above minConnections
+   */
+  autoDialInterval: number
+}
+
+export interface TransportManagerConfig {
+  faultTolerance?: FAULT_TOLERANCE
+}
+
+export interface PeerStoreConfig {
+  persistence?: boolean
+  threshold?: number
+}
+
+export interface PeerRoutingConfig {
+  refreshManager: RefreshManagerConfig
+}
+
+export interface RefreshManagerConfig {
+  enabled?: boolean
+  interval: number
+  bootDelay: number
+}
+
+export interface Libp2pInit {
+  peerId: PeerId
+  host: HostProperties
+  addresses: AddressesConfig
+  connectionManager: ConnectionManagerConfig
+  connectionGater: Partial<ConnectionGater>
+  transportManager: TransportManagerConfig
+  datastore: Datastore
+  dialer: DialerInit
+  metrics: MetricsInit
+  peerStore: PeerStoreInit
+  peerRouting: PeerRoutingConfig
+  keychain: KeychainConfig
+  protocolPrefix: string
+  nat: NatManagerConfig
+  relay: RelayConfig
+
+  transports: Transport[]
+  streamMuxers?: StreamMuxerFactory[]
+  connectionEncryption?: ConnectionEncrypter[]
+  peerDiscovery?: PeerDiscovery[]
+  peerRouters?: PeerRouting[]
+  contentRouters?: ContentRouting[]
+  dht?: DualDHT
+  pubsub?: PubSub
+  connectionProtector?: ConnectionProtector
+}
+
+export interface Libp2pEvents {
+  'peer:discovery': CustomEvent<PeerInfo>
+}
+
+export interface Libp2p extends Startable, EventEmitter<Libp2pEvents> {
+  peerId: PeerId
+  peerStore: PeerStore
+  peerRouting: PeerRouting
+  contentRouting: ContentRouting
+  keychain: KeyChain
+  connectionManager: ConnectionManager
+
+  pubsub?: PubSub
+  dht?: DualDHT
+
+  /**
+   * Load keychain keys from the datastore.
+   * Imports the private key as 'self', if needed.
+   */
+  loadKeychain: () => Promise<void>
+
+  /**
+   * Get a deduplicated list of peer advertising multiaddrs by concatenating
+   * the listen addresses used by transports with any configured
+   * announce addresses as well as observed addresses reported by peers.
+   *
+   * If Announce addrs are specified, configured listen addresses will be
+   * ignored though observed addresses will still be included.
+   */
+  getMultiaddrs: () => Multiaddr[]
+
+  /**
+   * Return a list of all connections this node has open, optionally filtering
+   * by a PeerId
+   */
+  getConnections: (peerId?: PeerId) => Connection[]
+
+  /**
+   * Return a list of all peers we currently have a connection open to
+   */
+  getPeers: () => PeerId[]
+
+  /**
+   * Dials to the provided peer. If successful, the known metadata of the
+   * peer will be added to the nodes `peerStore`
+   */
+  dial: (peer: PeerId | Multiaddr, options?: AbortOptions) => Promise<Connection>
+
+  /**
+   * Dials to the provided peer and tries to handshake with the given protocols in order.
+   * If successful, the known metadata of the peer will be added to the nodes `peerStore`,
+   * and the `MuxedStream` will be returned together with the successful negotiated protocol.
+   */
+  dialProtocol: (peer: PeerId | Multiaddr, protocols: string | string[], options?: AbortOptions) => Promise<ProtocolStream>
+
+  /**
+   * Disconnects all connections to the given `peer`
+   */
+  hangUp: (peer: PeerId | Multiaddr | string) => Promise<void>
+
+  /**
+   * Registers the `handler` for each protocol
+   */
+  handle: (protocol: string | string[], handler: StreamHandler) => Promise<void>
+
+  /**
+   * Removes the handler for each protocol. The protocol
+   * will no longer be supported on streams.
+   */
+  unhandle: (protocols: string[] | string) => Promise<void>
+
+  /**
+   * Pings the given peer in order to obtain the operation latency
+   */
+  ping: (peer: Multiaddr |PeerId) => Promise<number>
+
+  /**
+   * Sends a request to fetch the value associated with the given key from the given peer.
+   */
+  fetch: (peer: PeerId | Multiaddr | string, key: string) => Promise<Uint8Array | null>
+}
+
+export type Libp2pOptions = RecursivePartial<Libp2pInit>
+
+/**
+ * Returns a new instance of the Libp2p interface, generating a new PeerId
+ * if one is not passed as part of the options.
+ */
+export async function createLibp2p (options: Libp2pOptions): Promise<Libp2p> {
+  return await createLibp2pNode(options)
+}

package/src/insecure/index.ts

@@ -0,0 +1,97 @@
+import { logger } from '@libp2p/logger'
+import { handshake } from 'it-handshake'
+import * as lp from 'it-length-prefixed'
+import { UnexpectedPeerError, InvalidCryptoExchangeError } from '@libp2p/interfaces/connection-encrypter/errors'
+import { Exchange, IExchange, KeyType } from './pb/proto.js'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import { peerIdFromBytes, peerIdFromKeys } from '@libp2p/peer-id'
+import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interfaces/connection-encrypter'
+import type { Duplex } from 'it-stream-types'
+
+const log = logger('libp2p:plaintext')
+const PROTOCOL = '/plaintext/2.0.0'
+
+function lpEncodeExchange (exchange: IExchange) {
+  const pb = Exchange.encode(exchange).finish()
+
+  return lp.encode.single(pb)
+}
+
+/**
+ * Encrypt connection
+ */
+async function encrypt (localId: PeerId, conn: Duplex<Uint8Array>, remoteId?: PeerId): Promise<SecuredConnection> {
+  const shake = handshake(conn)
+
+  let type = KeyType.RSA
+
+  if (localId.type === 'Ed25519') {
+    type = KeyType.Ed25519
+  } else if (localId.type === 'secp256k1') {
+    type = KeyType.Secp256k1
+  }
+
+  // Encode the public key and write it to the remote peer
+  shake.write(
+    lpEncodeExchange({
+      id: localId.toBytes(),
+      pubkey: {
+        Type: type,
+        Data: localId.publicKey
+      }
+    }).slice()
+  )
+
+  log('write pubkey exchange to peer %p', remoteId)
+
+  // Get the Exchange message
+  // @ts-expect-error needs to be generator
+  const response = (await lp.decode.fromReader(shake.reader).next()).value
+  const id = Exchange.decode(response.slice())
+  log('read pubkey exchange from peer %p', remoteId)
+
+  let peerId
+  try {
+    if (id.pubkey.Data.length === 0) {
+      throw new Error('Public key data too short')
+    }
+
+    if (id.id == null) {
+      throw new Error('Remote id missing')
+    }
+
+    peerId = await peerIdFromKeys(id.pubkey.Data)
+
+    if (!peerId.equals(peerIdFromBytes(id.id))) {
+      throw new Error('Public key did not match id')
+    }
+  } catch (err: any) {
+    log.error(err)
+    throw new InvalidCryptoExchangeError('Remote did not provide its public key')
+  }
+
+  if (remoteId != null && !peerId.equals(remoteId)) {
+    throw new UnexpectedPeerError()
+  }
+
+  log('plaintext key exchange completed successfully with peer %p', peerId)
+
+  shake.rest()
+  return {
+    conn: shake.stream,
+    remotePeer: peerId,
+    remoteEarlyData: new Uint8Array()
+  }
+}
+
+export class Plaintext implements ConnectionEncrypter {
+  public protocol: string = PROTOCOL
+
+  async secureInbound (localId: PeerId, conn: Duplex<Uint8Array>, remoteId?: PeerId): Promise<SecuredConnection> {
+    return await encrypt(localId, conn, remoteId)
+  }
+
+  async secureOutbound (localId: PeerId, conn: Duplex<Uint8Array>, remoteId: PeerId): Promise<SecuredConnection> {
+    return await encrypt(localId, conn, remoteId)
+  }
+}