@agoric/network 0.1.1-dev-2f092c3.0

package/src/router.d.ts

@@ -0,0 +1,65 @@
+/**
+ * @template T
+ * @typedef {object} Router A delimited string router implementation
+ * @property {(addr: string) => [string, T][]} getRoutes Return the match and
+ *   route in order of preference
+ * @property {(prefix: string, route: T) => void} register Add a prefix->route
+ *   to the database
+ * @property {(prefix: string, route: T) => void} unregister Remove a
+ *   prefix->route from the database
+ */
+/**
+ * Create a slash-delimited router.
+ *
+ * @template T
+ * @returns {Router<T>} a new Router
+ */
+export default function makeRouter<T>(): Router<T>;
+/**
+ * @typedef {object} RouterProtocol
+ * @property {(prefix: string) => Promise<Port>} bind
+ * @property {(paths: string[], protocolHandler: ProtocolHandler) => void} registerProtocolHandler
+ * @property {(prefix: string, protocolHandler: ProtocolHandler) => void} unregisterProtocolHandler
+ */
+/**
+ * Create a router that behaves like a Protocol.
+ *
+ * @param {typeof defaultE} [E] Eventual sender
+ * @returns {RouterProtocol} The new delegated protocol
+ */
+export function makeRouterProtocol(E?: ((<T>(x: T) => import("@endo/eventual-send/src/E.js").ECallableOrMethods<import("@endo/eventual-send").RemoteFunctions<T>>) & {
+    readonly get: <T_1>(x: T_1) => import("@endo/eventual-send/src/E.js").EGetters<import("@endo/eventual-send").LocalRecord<T_1>>;
+    readonly resolve: {
+        (): Promise<void>;
+        <T_2>(value: T_2): Promise<Awaited<T_2>>;
+        <T_3>(value: T_3 | PromiseLike<T_3>): Promise<Awaited<T_3>>;
+    };
+    readonly sendOnly: <T_4>(x: T_4) => import("@endo/eventual-send/src/E.js").ESendOnlyCallableOrMethods<import("@endo/eventual-send").RemoteFunctions<T_4>>;
+    readonly when: <T_5, U = T_5>(x: T_5 | PromiseLike<T_5>, onfulfilled?: ((value: T_5) => import("@endo/eventual-send").ERef<U>) | undefined, onrejected?: ((reason: any) => import("@endo/eventual-send").ERef<U>) | undefined) => Promise<U>;
+}) | undefined): RouterProtocol;
+/**
+ * A delimited string router implementation
+ */
+export type Router<T> = {
+    /**
+     * Return the match and
+     * route in order of preference
+     */
+    getRoutes: (addr: string) => [string, T][];
+    /**
+     * Add a prefix->route
+     * to the database
+     */
+    register: (prefix: string, route: T) => void;
+    /**
+     * Remove a
+     * prefix->route from the database
+     */
+    unregister: (prefix: string, route: T) => void;
+};
+export type RouterProtocol = {
+    bind: (prefix: string) => Promise<Port>;
+    registerProtocolHandler: (paths: string[], protocolHandler: ProtocolHandler) => void;
+    unregisterProtocolHandler: (prefix: string, protocolHandler: ProtocolHandler) => void;
+};
+//# sourceMappingURL=router.d.ts.map

package/src/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["router.js"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AAEH;;;;;GAKG;AACH,mDAkCC;AAED;;;;;GAKG;AAEH;;;;;GAKG;AACH;;;;;;;;;iBAFa,cAAc,CAyC1B;;;;;;;;;sBAtGoB,MAAM,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE;;;;;uBAEtB,MAAM,SAAS,CAAC,KAAK,IAAI;;;;;yBAEzB,MAAM,SAAS,CAAC,KAAK,IAAI;;;mBAgDzB,MAAM,KAAK,QAAQ,IAAI,CAAC;qCACzB,MAAM,EAAE,mBAAmB,eAAe,KAAK,IAAI;wCAClD,MAAM,mBAAmB,eAAe,KAAK,IAAI"}

package/src/router.js

@@ -0,0 +1,114 @@
+import { Far, E as defaultE } from '@endo/far';
+import { makeScalarMapStore } from '@agoric/store';
+import { Fail } from '@agoric/assert';
+import { makeNetworkProtocol, ENDPOINT_SEPARATOR } from './network.js';
+
+import '@agoric/store/exported.js';
+import './types.js';
+
+/**
+ * @template T
+ * @typedef {object} Router A delimited string router implementation
+ * @property {(addr: string) => [string, T][]} getRoutes Return the match and
+ *   route in order of preference
+ * @property {(prefix: string, route: T) => void} register Add a prefix->route
+ *   to the database
+ * @property {(prefix: string, route: T) => void} unregister Remove a
+ *   prefix->route from the database
+ */
+
+/**
+ * Create a slash-delimited router.
+ *
+ * @template T
+ * @returns {Router<T>} a new Router
+ */
+export default function makeRouter() {
+  /** @type {MapStore<string, T>} */
+  const prefixToRoute = makeScalarMapStore('prefix');
+  return Far('Router', {
+    getRoutes(addr) {
+      const parts = addr.split(ENDPOINT_SEPARATOR);
+      /** @type {[string, T][]} */
+      const ret = [];
+      for (let i = parts.length; i > 0; i -= 1) {
+        // Try most specific match.
+        const prefix = parts.slice(0, i).join(ENDPOINT_SEPARATOR);
+        if (prefixToRoute.has(prefix)) {
+          ret.push([prefix, prefixToRoute.get(prefix)]);
+        }
+        // Trim off the last value (after the slash).
+        const defaultPrefix = prefix.substr(
+          0,
+          prefix.lastIndexOf(ENDPOINT_SEPARATOR) + 1,
+        );
+        if (prefixToRoute.has(defaultPrefix)) {
+          ret.push([defaultPrefix, prefixToRoute.get(defaultPrefix)]);
+        }
+      }
+      return harden(ret);
+    },
+    register(prefix, route) {
+      prefixToRoute.init(prefix, route);
+    },
+    unregister(prefix, route) {
+      prefixToRoute.get(prefix) === route ||
+        Fail`Router is not registered at prefix ${prefix}`;
+      prefixToRoute.delete(prefix);
+    },
+  });
+}
+
+/**
+ * @typedef {object} RouterProtocol
+ * @property {(prefix: string) => Promise<Port>} bind
+ * @property {(paths: string[], protocolHandler: ProtocolHandler) => void} registerProtocolHandler
+ * @property {(prefix: string, protocolHandler: ProtocolHandler) => void} unregisterProtocolHandler
+ */
+
+/**
+ * Create a router that behaves like a Protocol.
+ *
+ * @param {typeof defaultE} [E] Eventual sender
+ * @returns {RouterProtocol} The new delegated protocol
+ */
+export function makeRouterProtocol(E = defaultE) {
+  const router = makeRouter();
+  /** @type {MapStore<string, Protocol>} */
+  const protocols = makeScalarMapStore('prefix');
+  /** @type {MapStore<string, ProtocolHandler>} */
+  const protocolHandlers = makeScalarMapStore('prefix');
+
+  function registerProtocolHandler(paths, protocolHandler) {
+    const protocol = makeNetworkProtocol(protocolHandler);
+    for (const prefix of paths) {
+      router.register(prefix, protocol);
+      protocols.init(prefix, protocol);
+      protocolHandlers.init(prefix, protocolHandler);
+    }
+  }
+
+  // FIXME: Buggy.
+  // Needs to account for multiple paths.
+  function unregisterProtocolHandler(prefix, protocolHandler) {
+    const ph = protocolHandlers.get(prefix);
+    ph === protocolHandler ||
+      Fail`Protocol handler is not registered at prefix ${prefix}`;
+    router.unregister(prefix, ph);
+    protocols.delete(prefix);
+    protocolHandlers.delete(prefix);
+  }
+
+  /** @type {Protocol['bind']} */
+  async function bind(localAddr) {
+    const [route] = router.getRoutes(localAddr);
+    route !== undefined || Fail`No registered router for ${localAddr}`;
+    return E(route[1]).bind(localAddr);
+  }
+
+  return Far('RouterProtocol', {
+    bind,
+    registerProtocolHandler,
+    unregisterProtocolHandler,
+  });
+}

package/src/types.d.ts

@@ -0,0 +1,205 @@
+type Data = string | Buffer | ArrayBuffer;
+type Bytes = string;
+/**
+ * A local or remote address See multiaddr.js for an
+ *   opinionated router implementation
+ */
+type Endpoint = string;
+/**
+ * A closable object
+ */
+type Closable = {
+    /**
+     * Terminate the object
+     */
+    close: () => Promise<void>;
+};
+/**
+ * The network Protocol
+ */
+type Protocol = {
+    /**
+     * Claim a port, or if
+     * ending in ENDPOINT_SEPARATOR, a fresh name
+     */
+    bind: (prefix: Endpoint) => Promise<Port>;
+};
+/**
+ * A port that has been bound to a protocol
+ */
+type Port = {
+    /**
+     * Get the locally bound name of this
+     * port
+     */
+    getLocalAddress: () => Endpoint;
+    /**
+     *   Begin accepting incoming connections
+     */
+    addListener: (acceptHandler: ListenHandler) => Promise<void>;
+    /**
+     *   Make an outbound connection
+     */
+    connect: (remote: Endpoint, connectionHandler?: ConnectionHandler) => Promise<Connection>;
+    /**
+     *   Remove the currently-bound listener
+     */
+    removeListener: (acceptHandler: ListenHandler) => Promise<void>;
+    /**
+     * Deallocate the port entirely, removing all
+     * listeners and closing all active connections
+     */
+    revoke: () => void;
+};
+/**
+ * A handler for incoming connections
+ */
+type ListenHandler = {
+    /**
+     * The
+     * listener has been registered
+     */
+    onListen?: ((port: Port, l: ListenHandler) => Promise<void>) | undefined;
+    /**
+     *   A new connection is incoming
+     */
+    onAccept: (port: Port, localAddr: Endpoint, remoteAddr: Endpoint, l: ListenHandler) => Promise<ConnectionHandler>;
+    /**
+     * The connection was rejected
+     */
+    onReject?: ((port: Port, localAddr: Endpoint, remoteAddr: Endpoint, l: ListenHandler) => Promise<void>) | undefined;
+    /**
+     * There was an error while listening
+     */
+    onError?: ((port: Port, rej: any, l: ListenHandler) => Promise<void>) | undefined;
+    /**
+     * The
+     * listener has been removed
+     */
+    onRemove?: ((port: Port, l: ListenHandler) => Promise<void>) | undefined;
+};
+type Connection = {
+    /**
+     *   Send a packet on the connection
+     */
+    send: (packetBytes: Data, opts?: Record<string, any>) => Promise<Bytes>;
+    /**
+     * Close both ends of the connection
+     */
+    close: () => Promise<void>;
+    /**
+     * Get the locally bound name of this
+     * connection
+     */
+    getLocalAddress: () => Endpoint;
+    /**
+     * Get the name of the counterparty
+     */
+    getRemoteAddress: () => Endpoint;
+};
+/**
+ * A handler for a given Connection
+ */
+type ConnectionHandler = {
+    /**
+     * The connection has been opened
+     */
+    onOpen?: ((connection: Connection, localAddr: Endpoint, remoteAddr: Endpoint, c: ConnectionHandler) => void) | undefined;
+    /**
+     * The connection received a packet
+     */
+    onReceive?: ((connection: Connection, packetBytes: Bytes, c: ConnectionHandler, opts?: Record<string, any>) => Promise<Data>) | undefined;
+    /**
+     * The connection has been closed
+     */
+    onClose?: ((connection: Connection, reason?: CloseReason, c?: ConnectionHandler) => Promise<void>) | undefined;
+};
+/**
+ * The reason a connection was closed
+ */
+type CloseReason = any | null;
+type AttemptDescription = {
+    handler: ConnectionHandler;
+    remoteAddress?: string | undefined;
+    localAddress?: string | undefined;
+};
+/**
+ * A handler for things the protocol
+ *   implementation will invoke
+ */
+type ProtocolHandler = {
+    /**
+     *   This protocol is created
+     */
+    onCreate: (protocol: ProtocolImpl, p: ProtocolHandler) => Promise<void>;
+    /**
+     *   Create a fresh port identifier for this protocol
+     */
+    generatePortID: (localAddr: Endpoint, p: ProtocolHandler) => Promise<string>;
+    /**
+     *   A port will be bound
+     */
+    onBind: (port: Port, localAddr: Endpoint, p: ProtocolHandler) => Promise<void>;
+    /**
+     *   A port was listening
+     */
+    onListen: (port: Port, localAddr: Endpoint, listenHandler: ListenHandler, p: ProtocolHandler) => Promise<void>;
+    /**
+     *   A port listener has been reset
+     */
+    onListenRemove: (port: Port, localAddr: Endpoint, listenHandler: ListenHandler, p: ProtocolHandler) => Promise<void>;
+    /**
+     * Return unique suffix for local address
+     */
+    onInstantiate?: ((port: Port, localAddr: Endpoint, remote: Endpoint, p: ProtocolHandler) => Promise<Endpoint>) | undefined;
+    /**
+     *   A port initiates an outbound connection
+     */
+    onConnect: (port: Port, localAddr: Endpoint, remote: Endpoint, c: ConnectionHandler, p: ProtocolHandler) => Promise<AttemptDescription>;
+    /**
+     *   The port is being completely destroyed
+     */
+    onRevoke: (port: Port, localAddr: Endpoint, p: ProtocolHandler) => Promise<void>;
+};
+/**
+ * An inbound connection attempt
+ */
+type InboundAttempt = {
+    /**
+     *   Establish the connection
+     */
+    accept: (desc: AttemptDescription) => Promise<Connection>;
+    /**
+     * Return the local address for this
+     * attempt
+     */
+    getLocalAddress: () => Endpoint;
+    /**
+     * Return the remote address for
+     * this attempt
+     */
+    getRemoteAddress: () => Endpoint;
+    /**
+     * Abort the attempt
+     */
+    close: () => Promise<void>;
+};
+/**
+ * Things the protocol can do for us
+ */
+type ProtocolImpl = {
+    /**
+     * Claim a port, or if
+     * ending in ENDPOINT_SEPARATOR, a fresh name
+     */
+    bind: (prefix: Endpoint) => Promise<Port>;
+    /**
+     *   Make an attempt to connect into this protocol
+     */
+    inbound: (listenAddr: Endpoint, remoteAddr: Endpoint) => Promise<InboundAttempt>;
+    /**
+     *   Create an outbound connection
+     */
+    outbound: (port: Port, remoteAddr: Endpoint, connectionHandler: ConnectionHandler) => Promise<Connection>;
+};
+//# sourceMappingURL=types.d.ts.map

package/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":"YACa,MAAM,GAAG,MAAM,GAAG,WAAW;aAE7B,MAAM;;;;;gBAIN,MAAM;;;;;;;;WAML,MAAM,QAAQ,IAAI,CAAC;;;;;;;;;;mBAKV,QAAQ,KAAK,QAAQ,IAAI,CAAC;;;;;;;;;;qBAMnC,MAAM,QAAQ;;;;iCAEE,aAAa,KAAK,QAAQ,IAAI,CAAC;;;;sBAGhD,QAAQ,sBACI,iBAAiB,KAClC,QAAQ,UAAU,CAAC;;;;oCAEG,aAAa,KAAK,QAAQ,IAAI,CAAC;;;;;YAE/C,MAAM,IAAI;;;;;;;;;;uBAMH,IAAI,KAAK,aAAa,KAAK,QAAQ,IAAI,CAAC;;;;qBAGlD,IAAI,aACC,QAAQ,cACP,QAAQ,KACjB,aAAa,KACb,QAAQ,iBAAiB,CAAC;;;;uBAGvB,IAAI,aACC,QAAQ,cACP,QAAQ,KACjB,aAAa,KACb,QAAQ,IAAI,CAAC;;;;sBAEA,IAAI,OAAO,GAAG,KAAK,aAAa,KAAK,QAAQ,IAAI,CAAC;;;;;uBAElD,IAAI,KAAK,aAAa,KAAK,QAAQ,IAAI,CAAC;;;;;;wBAO3C,IAAI,SACV,OAAO,MAAM,EAAE,GAAG,CAAC,KACvB,QAAQ,KAAK,CAAC;;;;WAER,MAAM,QAAQ,IAAI,CAAC;;;;;qBACnB,MAAM,QAAQ;;;;sBAEd,MAAM,QAAQ;;;;;;;;;2BAMX,UAAU,aACX,QAAQ,cACP,QAAQ,KACjB,iBAAiB,KACjB,IAAI;;;;8BAGK,UAAU,eACT,KAAK,KACf,iBAAiB,SACb,OAAO,MAAM,EAAE,GAAG,CAAC,KACvB,QAAQ,IAAI,CAAC;;;;4BAGJ,UAAU,WACb,WAAW,MAChB,iBAAiB,KAClB,QAAQ,IAAI,CAAC;;;;;mBAGR,GAAG,GAAG,IAAI;;aAKT,iBAAiB;;;;;;;;;;;;yBAQN,YAAY,KAAK,eAAe,KAAK,QAAQ,IAAI,CAAC;;;;gCAEjD,QAAQ,KAAK,eAAe,KAAK,QAAQ,MAAM,CAAC;;;;mBAG/D,IAAI,aACC,QAAQ,KAChB,eAAe,KACf,QAAQ,IAAI,CAAC;;;;qBAGV,IAAI,aACC,QAAQ,iBACJ,aAAa,KACzB,eAAe,KACf,QAAQ,IAAI,CAAC;;;;2BAGV,IAAI,aACC,QAAQ,iBACJ,aAAa,KACzB,eAAe,KACf,QAAQ,IAAI,CAAC;;;;4BAGV,IAAI,aACC,QAAQ,UACX,QAAQ,KACb,eAAe,KACf,QAAQ,QAAQ,CAAC;;;;sBAGd,IAAI,aACC,QAAQ,UACX,QAAQ,KACb,iBAAiB,KACjB,eAAe,KACf,QAAQ,kBAAkB,CAAC;;;;qBAGxB,IAAI,aACC,QAAQ,KAChB,eAAe,KACf,QAAQ,IAAI,CAAC;;;;;;;;;mBAIA,kBAAkB,KAAK,QAAQ,UAAU,CAAC;;;;;qBAEjD,MAAM,QAAQ;;;;;sBAEd,MAAM,QAAQ;;;;WAEd,MAAM,QAAQ,IAAI,CAAC;;;;;;;;;;mBAGV,QAAQ,KAAK,QAAQ,IAAI,CAAC;;;;0BAGhC,QAAQ,cACR,QAAQ,KACjB,QAAQ,cAAc,CAAC;;;;qBAGpB,IAAI,cACE,QAAQ,qBACD,iBAAiB,KACjC,QAAQ,UAAU,CAAC"}

package/src/types.js

@@ -0,0 +1,182 @@
+/**
+ * @typedef {string | Buffer | ArrayBuffer} Data
+ *
+ * @typedef {string} Bytes
+ */
+
+/**
+ * @typedef {string} Endpoint A local or remote address See multiaddr.js for an
+ *   opinionated router implementation
+ */
+
+/**
+ * @typedef {object} Closable A closable object
+ * @property {() => Promise<void>} close Terminate the object
+ */
+
+/**
+ * @typedef {object} Protocol The network Protocol
+ * @property {(prefix: Endpoint) => Promise<Port>} bind Claim a port, or if
+ *   ending in ENDPOINT_SEPARATOR, a fresh name
+ */
+
+/**
+ * @typedef {object} Port A port that has been bound to a protocol
+ * @property {() => Endpoint} getLocalAddress Get the locally bound name of this
+ *   port
+ * @property {(acceptHandler: ListenHandler) => Promise<void>} addListener
+ *   Begin accepting incoming connections
+ * @property {(
+ *   remote: Endpoint,
+ *   connectionHandler?: ConnectionHandler,
+ * ) => Promise<Connection>} connect
+ *   Make an outbound connection
+ * @property {(acceptHandler: ListenHandler) => Promise<void>} removeListener
+ *   Remove the currently-bound listener
+ * @property {() => void} revoke Deallocate the port entirely, removing all
+ *   listeners and closing all active connections
+ */
+
+/**
+ * @typedef {object} ListenHandler A handler for incoming connections
+ * @property {(port: Port, l: ListenHandler) => Promise<void>} [onListen] The
+ *   listener has been registered
+ * @property {(
+ *   port: Port,
+ *   localAddr: Endpoint,
+ *   remoteAddr: Endpoint,
+ *   l: ListenHandler,
+ * ) => Promise<ConnectionHandler>} onAccept
+ *   A new connection is incoming
+ * @property {(
+ *   port: Port,
+ *   localAddr: Endpoint,
+ *   remoteAddr: Endpoint,
+ *   l: ListenHandler,
+ * ) => Promise<void>} [onReject]
+ *   The connection was rejected
+ * @property {(port: Port, rej: any, l: ListenHandler) => Promise<void>} [onError]
+ *   There was an error while listening
+ * @property {(port: Port, l: ListenHandler) => Promise<void>} [onRemove] The
+ *   listener has been removed
+ */
+
+/**
+ * @typedef {object} Connection
+ * @property {(
+ *   packetBytes: Data,
+ *   opts?: Record<string, any>,
+ * ) => Promise<Bytes>} send
+ *   Send a packet on the connection
+ * @property {() => Promise<void>} close Close both ends of the connection
+ * @property {() => Endpoint} getLocalAddress Get the locally bound name of this
+ *   connection
+ * @property {() => Endpoint} getRemoteAddress Get the name of the counterparty
+ */
+
+/**
+ * @typedef {object} ConnectionHandler A handler for a given Connection
+ * @property {(
+ *   connection: Connection,
+ *   localAddr: Endpoint,
+ *   remoteAddr: Endpoint,
+ *   c: ConnectionHandler,
+ * ) => void} [onOpen]
+ *   The connection has been opened
+ * @property {(
+ *   connection: Connection,
+ *   packetBytes: Bytes,
+ *   c: ConnectionHandler,
+ *   opts?: Record<string, any>,
+ * ) => Promise<Data>} [onReceive]
+ *   The connection received a packet
+ * @property {(
+ *   connection: Connection,
+ *   reason?: CloseReason,
+ *   c?: ConnectionHandler,
+ * ) => Promise<void>} [onClose]
+ *   The connection has been closed
+ *
+ * @typedef {any | null} CloseReason The reason a connection was closed
+ */
+
+/**
+ * @typedef {object} AttemptDescription
+ * @property {ConnectionHandler} handler
+ * @property {Endpoint} [remoteAddress]
+ * @property {Endpoint} [localAddress]
+ */
+
+/**
+ * @typedef {object} ProtocolHandler A handler for things the protocol
+ *   implementation will invoke
+ * @property {(protocol: ProtocolImpl, p: ProtocolHandler) => Promise<void>} onCreate
+ *   This protocol is created
+ * @property {(localAddr: Endpoint, p: ProtocolHandler) => Promise<string>} generatePortID
+ *   Create a fresh port identifier for this protocol
+ * @property {(
+ *   port: Port,
+ *   localAddr: Endpoint,
+ *   p: ProtocolHandler,
+ * ) => Promise<void>} onBind
+ *   A port will be bound
+ * @property {(
+ *   port: Port,
+ *   localAddr: Endpoint,
+ *   listenHandler: ListenHandler,
+ *   p: ProtocolHandler,
+ * ) => Promise<void>} onListen
+ *   A port was listening
+ * @property {(
+ *   port: Port,
+ *   localAddr: Endpoint,
+ *   listenHandler: ListenHandler,
+ *   p: ProtocolHandler,
+ * ) => Promise<void>} onListenRemove
+ *   A port listener has been reset
+ * @property {(
+ *   port: Port,
+ *   localAddr: Endpoint,
+ *   remote: Endpoint,
+ *   p: ProtocolHandler,
+ * ) => Promise<Endpoint>} [onInstantiate]
+ *   Return unique suffix for local address
+ * @property {(
+ *   port: Port,
+ *   localAddr: Endpoint,
+ *   remote: Endpoint,
+ *   c: ConnectionHandler,
+ *   p: ProtocolHandler,
+ * ) => Promise<AttemptDescription>} onConnect
+ *   A port initiates an outbound connection
+ * @property {(
+ *   port: Port,
+ *   localAddr: Endpoint,
+ *   p: ProtocolHandler,
+ * ) => Promise<void>} onRevoke
+ *   The port is being completely destroyed
+ *
+ * @typedef {object} InboundAttempt An inbound connection attempt
+ * @property {(desc: AttemptDescription) => Promise<Connection>} accept
+ *   Establish the connection
+ * @property {() => Endpoint} getLocalAddress Return the local address for this
+ *   attempt
+ * @property {() => Endpoint} getRemoteAddress Return the remote address for
+ *   this attempt
+ * @property {() => Promise<void>} close Abort the attempt
+ *
+ * @typedef {object} ProtocolImpl Things the protocol can do for us
+ * @property {(prefix: Endpoint) => Promise<Port>} bind Claim a port, or if
+ *   ending in ENDPOINT_SEPARATOR, a fresh name
+ * @property {(
+ *   listenAddr: Endpoint,
+ *   remoteAddr: Endpoint,
+ * ) => Promise<InboundAttempt>} inbound
+ *   Make an attempt to connect into this protocol
+ * @property {(
+ *   port: Port,
+ *   remoteAddr: Endpoint,
+ *   connectionHandler: ConnectionHandler,
+ * ) => Promise<Connection>} outbound
+ *   Create an outbound connection
+ */