@agoric/swingset-vat 0.32.3-dev-a2db142.0 → 0.32.3-dev-9d4eaad.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/swingset-vat",
-  "version": "0.32.3-dev-a2db142.0+a2db142",
+  "version": "0.32.3-dev-9d4eaad.0+9d4eaad",
   "description": "Vat/Container Launcher",
   "type": "module",
   "main": "src/index.js",
@@ -27,16 +27,16 @@
     "@types/yargs-parser": "^21.0.0"
   },
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-a2db142.0+a2db142",
-    "@agoric/internal": "0.3.3-dev-a2db142.0+a2db142",
-    "@agoric/store": "0.9.3-dev-a2db142.0+a2db142",
-    "@agoric/swing-store": "0.9.2-dev-a2db142.0+a2db142",
-    "@agoric/swingset-liveslots": "0.10.3-dev-a2db142.0+a2db142",
-    "@agoric/swingset-xsnap-supervisor": "0.10.3-dev-a2db142.0+a2db142",
-    "@agoric/time": "0.3.3-dev-a2db142.0+a2db142",
-    "@agoric/vat-data": "0.5.3-dev-a2db142.0+a2db142",
-    "@agoric/xsnap": "0.14.3-dev-a2db142.0+a2db142",
-    "@agoric/xsnap-lockdown": "0.14.1-dev-a2db142.0+a2db142",
+    "@agoric/assert": "0.6.1-dev-9d4eaad.0+9d4eaad",
+    "@agoric/internal": "0.3.3-dev-9d4eaad.0+9d4eaad",
+    "@agoric/store": "0.9.3-dev-9d4eaad.0+9d4eaad",
+    "@agoric/swing-store": "0.9.2-dev-9d4eaad.0+9d4eaad",
+    "@agoric/swingset-liveslots": "0.10.3-dev-9d4eaad.0+9d4eaad",
+    "@agoric/swingset-xsnap-supervisor": "0.10.3-dev-9d4eaad.0+9d4eaad",
+    "@agoric/time": "0.3.3-dev-9d4eaad.0+9d4eaad",
+    "@agoric/vat-data": "0.5.3-dev-9d4eaad.0+9d4eaad",
+    "@agoric/xsnap": "0.14.3-dev-9d4eaad.0+9d4eaad",
+    "@agoric/xsnap-lockdown": "0.14.1-dev-9d4eaad.0+9d4eaad",
     "@endo/base64": "^0.2.32",
     "@endo/bundle-source": "^2.5.2",
     "@endo/captp": "^3.1.2",
@@ -93,5 +93,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "a2db1428393bcca3175179f9cfe76c92a4eb1b3f"
+  "gitHead": "9d4eaadaa3caa031a0410f747ff06a4855ece40a"
 }

package/src/vats/network/bytes.js

@@ -1,63 +0,0 @@
-import './types.js';
-import { encodeBase64, decodeBase64 } from '@endo/base64';
-
-/* eslint-disable no-bitwise */
-/**
- * Convert some data to bytes.
- *
- * @param {Data} data
- * @returns {Bytes}
- */
-export function toBytes(data) {
-  /** @type {Data | number[]} */
-  let bytes = data;
-  // TODO: We really need marshallable TypedArrays.
-  if (typeof bytes === 'string') {
-    bytes = bytes.split('').map(c => c.charCodeAt(0));
-  }
-
-  // We return the raw characters in the lower half of
-  // the String's representation.
-  const buf = new Uint8Array(bytes);
-  return String.fromCharCode.apply(null, buf);
-}
-
-/**
- * Convert bytes to a String.
- *
- * @param {Bytes} bytes
- * @returns {string}
- */
-export function bytesToString(bytes) {
-  return bytes;
-}
-
-/**
- * Base64, as specified in https://tools.ietf.org/html/rfc4648#section-4
- *
- * @param {Data} data
- * @returns {string} base64 encoding
- */
-export function dataToBase64(data) {
-  /** @type {Uint8Array?} */
-  let bytes;
-  if (typeof data === 'string') {
-    bytes = new Uint8Array(data.length);
-    for (let i = 0; i < data.length; i += 1) {
-      bytes[i] = data.charCodeAt(i);
-    }
-  } else {
-    bytes = new Uint8Array(data);
-  }
-  return encodeBase64(bytes);
-}
-
-/**
- * Decodes a string into base64.
- *
- * @param {string} string Base64-encoded string
- * @returns {Bytes} decoded bytes
- */
-export function base64ToBytes(string) {
-  return toBytes(decodeBase64(string));
-}

package/src/vats/network/index.js

@@ -1,4 +0,0 @@
-export * from './network.js';
-export { default as makeRouter } from './router.js';
-export * from './multiaddr.js';
-export * from './bytes.js';

package/src/vats/network/multiaddr.js

@@ -1,65 +0,0 @@
-/**
- * @typedef {[string, string][]} Multiaddr
- * @typedef {string} Textaddr An address string formatted as in https://github.com/multiformats/multiaddr
- *
- * Here is the difference between Textaddr and Multiaddr:
- *
- * unspecified port on local ibc interface: /if/ibc0 [['if', 'ibc0']]
- * specific local port: /if/ibc0/ordered/transfer [['if', 'ibc0'], ['ordered', 'transfer']]
- *
- * remote pointer to chain: /dnsaddr/ibc.testnet.agoric.com/ordered/transfer
- *   [['dnsaddr', 'ibc.testnet.agoric.com'], ['ordered', 'transfer']]
- * resolve step to another pointer: /dnsaddr/rpc.testnet.agoric.com/ibc/testnet-1.19.0/gci/4bc8d.../ordered/transfer
- *   [['dnsaddr', 'rpc.testnet.agoric.com'], ['ibc', 'testnet-1.19.0'], ['gci', '4bc8d...'], ['ordered', 'transfer']]
- * resolve to the individual interfaces: /ip4/172.17.0.4/tcp/26657/tendermint/0.33/ibc/testnet-1.19.0/gci/4bc8d.../ordered/transfer
- *   [['ip4', '172.17.0.4'], ['tcp', '26657'], ['tendermint', '0.33'],
- *    ['ibc', 'testnet-1.19.0'], ['gci', '4bc8d...'], ['ordered', 'transfer']]
- */
-
-/**
- * Transform a text address to a parsed multiaddr
- *
- * @param {Textaddr} ma
- * @returns {Multiaddr}
- */
-export function parse(ma) {
-  if (typeof ma !== 'string') {
-    return ma;
-  }
-  let s = ma;
-  let m;
-  /**
-   * @type {[string, string][]}
-   */
-  const acc = [];
-  // eslint-disable-next-line no-cond-assign
-  while ((m = s.match(/^\/([^/]*)(\/([^/]*))?/))) {
-    s = s.substr(m[0].length);
-    if (m[2]) {
-      acc.push([m[1], m[3]]);
-    } else {
-      // @ts-expect-error '[string]' is not assignable to parameter of type '[string, string]'
-      acc.push([m[1]]);
-    }
-  }
-  if (s !== '' || s === ma) {
-    throw TypeError(
-      `Error parsing Multiaddr ${JSON.stringify(ma)} at ${JSON.stringify(s)}`,
-    );
-  }
-  return acc;
-}
-
-/**
- * Transform a parsed multiaddr to a string.
- *
- * @param {Multiaddr|Textaddr} ma
- * @returns {Textaddr}
- */
-export function unparse(ma) {
-  if (typeof ma === 'string') {
-    return ma;
-  }
-  const joined = ma.map(kv => kv.join('/')).join('/');
-  return `/${joined}`;
-}

package/src/vats/network/network.js

@@ -1,610 +0,0 @@
-import { makeScalarMapStore, makeLegacyMap } from '@agoric/store';
-import { Far, E } from '@endo/far';
-import { makePromiseKit } from '@endo/promise-kit';
-import { Fail } from '@agoric/assert';
-import { whileTrue } from '@agoric/internal';
-import { toBytes } from './bytes.js';
-
-import '@agoric/store/exported.js';
-import './types.js';
-
-/**
- * Compatibility note: this must match what our peers use,
- * so don't change it casually.
- */
-export const ENDPOINT_SEPARATOR = '/';
-
-export const rethrowUnlessMissing = err => {
-  // Ugly hack rather than being able to determine if the function
-  // exists.
-  if (
-    !(err instanceof TypeError) ||
-    !err.message.match(/target has no method|is not a function$/)
-  ) {
-    throw err;
-  }
-  return undefined;
-};
-
-/**
- * Create a handled Connection.
- *
- * @param {ConnectionHandler} handler
- * @param {Endpoint} localAddr
- * @param {Endpoint} remoteAddr
- * @param {Set<Closable>} [current]
- * @returns {Connection}
- */
-export const makeConnection = (
-  handler,
-  localAddr,
-  remoteAddr,
-  current = new Set(),
-) => {
-  let closed;
-  /**
-   * @type {Set<import('@endo/promise-kit').PromiseKit<Bytes>>}
-   */
-  const pendingAcks = new Set();
-  /**
-   * @type {Connection}
-   */
-  const connection = Far('Connection', {
-    getLocalAddress() {
-      return localAddr;
-    },
-    getRemoteAddress() {
-      return remoteAddr;
-    },
-    async close() {
-      if (closed) {
-        throw closed;
-      }
-      current.delete(connection);
-      closed = Error('Connection closed');
-      for (const ackDeferred of [...pendingAcks.values()]) {
-        pendingAcks.delete(ackDeferred);
-        ackDeferred.reject(closed);
-      }
-      await E(handler)
-        .onClose(connection, undefined, handler)
-        .catch(rethrowUnlessMissing);
-    },
-    async send(data, opts) {
-      // console.log('send', data, local === srcHandler);
-      if (closed) {
-        throw closed;
-      }
-      const bytes = toBytes(data);
-      const ackDeferred = makePromiseKit();
-      pendingAcks.add(ackDeferred);
-      E(handler)
-        .onReceive(connection, bytes, handler, opts)
-        .catch(err => {
-          rethrowUnlessMissing(err);
-          return '';
-        })
-        .then(
-          ack => {
-            pendingAcks.delete(ackDeferred);
-            ackDeferred.resolve(toBytes(ack));
-          },
-          err => {
-            pendingAcks.delete(ackDeferred);
-            ackDeferred.reject(err);
-          },
-        );
-      return ackDeferred.promise;
-    },
-  });
-
-  current.add(connection);
-  E(handler)
-    .onOpen(connection, localAddr, remoteAddr, handler)
-    .catch(rethrowUnlessMissing);
-  return connection;
-};
-
-/**
- * @param {ConnectionHandler} handler0
- * @param {Endpoint} addr0
- * @param {ConnectionHandler} handler1
- * @param {Endpoint} addr1
- * @param {WeakSet<Connection>} [current]
- * @returns {[Connection, Connection]}
- */
-export function crossoverConnection(
-  handler0,
-  addr0,
-  handler1,
-  addr1,
-  current = new WeakSet(),
-) {
-  /**
-   * @type {Connection[]}
-   */
-  const conns = [];
-  /**
-   * @type {ConnectionHandler[]}
-   */
-  const handlers = [handler0, handler1];
-  /**
-   * @type {Endpoint[]}
-   */
-  const addrs = [addr0, addr1];
-
-  function makeHalfConnection(l, r) {
-    let closed;
-    conns[l] = Far('Connection', {
-      getLocalAddress() {
-        return addrs[l];
-      },
-      getRemoteAddress() {
-        return addrs[r];
-      },
-      async send(packetBytes) {
-        if (closed) {
-          throw closed;
-        }
-        const ack = await E(handlers[r])
-          .onReceive(conns[r], toBytes(packetBytes), handlers[r])
-          .catch(rethrowUnlessMissing);
-        return toBytes(ack || '');
-      },
-      async close() {
-        if (closed) {
-          throw closed;
-        }
-        closed = Error('Connection closed');
-        current.delete(conns[l]);
-        await E(handlers[l])
-          .onClose(conns[l], undefined, handlers[l])
-          .catch(rethrowUnlessMissing);
-      },
-    });
-  }
-
-  makeHalfConnection(0, 1);
-  makeHalfConnection(1, 0);
-
-  /**
-   * @param {number} l local side of the connection
-   * @param {number} r remote side of the connection
-   */
-  function openHalfConnection(l, r) {
-    current.add(conns[l]);
-    E(handlers[l])
-      .onOpen(conns[l], addrs[l], addrs[r], handlers[l])
-      .catch(rethrowUnlessMissing);
-  }
-
-  openHalfConnection(0, 1);
-  openHalfConnection(1, 0);
-
-  const [conn0, conn1] = conns;
-  return [conn0, conn1];
-}
-
-/**
- * Get the list of prefixes from longest to shortest.
- *
- * @param {string} addr
- */
-export function getPrefixes(addr) {
-  const parts = addr.split(ENDPOINT_SEPARATOR);
-
-  /**
-   * @type {string[]}
-   */
-  const ret = [];
-  for (let i = parts.length; i > 0; i -= 1) {
-    // Try most specific match.
-    const prefix = parts.slice(0, i).join(ENDPOINT_SEPARATOR);
-    ret.push(prefix);
-  }
-  return ret;
-}
-
-/**
- * Create a protocol that has a handler.
- *
- * @param {ProtocolHandler} protocolHandler
- * @returns {Protocol} the local capability for connecting and listening
- */
-export function makeNetworkProtocol(protocolHandler) {
-  /** @type {LegacyMap<Port, Set<Closable>>} */
-  // Legacy because we're storing a JS Set
-  const currentConnections = makeLegacyMap('port');
-
-  /**
-   * Currently must be a single listenHandler.
-   * TODO: Do something sensible with multiple handlers?
-   *
-   * @type {MapStore<Endpoint, [Port, ListenHandler]>}
-   */
-  const listening = makeScalarMapStore('localAddr');
-
-  /**
-   * @type {MapStore<string, Port>}
-   */
-  const boundPorts = makeScalarMapStore('localAddr');
-
-  /**
-   * @param {Endpoint} localAddr
-   */
-  const bind = async localAddr => {
-    // Check if we are underspecified (ends in slash)
-    const underspecified = localAddr.endsWith(ENDPOINT_SEPARATOR);
-    for await (const _ of whileTrue(() => underspecified)) {
-      const portID = await E(protocolHandler).generatePortID(
-        localAddr,
-        protocolHandler,
-      );
-      const newAddr = `${localAddr}${portID}`;
-      if (!boundPorts.has(newAddr)) {
-        localAddr = newAddr;
-        break;
-      }
-    }
-
-    if (boundPorts.has(localAddr)) {
-      return boundPorts.get(localAddr);
-    }
-
-    /**
-     * @enum {number}
-     */
-    const RevokeState = {
-      NOT_REVOKED: 0,
-      REVOKING: 1,
-      REVOKED: 2,
-    };
-
-    /**
-     * @type {RevokeState}
-     */
-    let revoked = RevokeState.NOT_REVOKED;
-    const openConnections = new Set();
-
-    /**
-     * @type {Port}
-     */
-    const port = Far('Port', {
-      getLocalAddress() {
-        // Works even after revoke().
-        return localAddr;
-      },
-      async addListener(listenHandler) {
-        !revoked || Fail`Port ${localAddr} is revoked`;
-        listenHandler || Fail`listenHandler is not defined`;
-        if (listening.has(localAddr)) {
-          // Last one wins.
-          const [lport, lhandler] = listening.get(localAddr);
-          if (lhandler === listenHandler) {
-            return;
-          }
-          listening.set(localAddr, [port, listenHandler]);
-          E(lhandler).onRemove(lport, lhandler).catch(rethrowUnlessMissing);
-        } else {
-          listening.init(localAddr, [port, listenHandler]);
-        }
-
-        // TODO: Check that the listener defines onAccept.
-
-        await E(protocolHandler).onListen(
-          port,
-          localAddr,
-          listenHandler,
-          protocolHandler,
-        );
-        await E(listenHandler)
-          .onListen(port, listenHandler)
-          .catch(rethrowUnlessMissing);
-      },
-      async removeListener(listenHandler) {
-        listening.has(localAddr) || Fail`Port ${localAddr} is not listening`;
-        listening.get(localAddr)[1] === listenHandler ||
-          Fail`Port ${localAddr} handler to remove is not listening`;
-        listening.delete(localAddr);
-        await E(protocolHandler).onListenRemove(
-          port,
-          localAddr,
-          listenHandler,
-          protocolHandler,
-        );
-        await E(listenHandler)
-          .onRemove(port, listenHandler)
-          .catch(rethrowUnlessMissing);
-      },
-      async connect(remotePort, connectionHandler = {}) {
-        !revoked || Fail`Port ${localAddr} is revoked`;
-        /**
-         * @type {Endpoint}
-         */
-        const dst = harden(remotePort);
-        // eslint-disable-next-line no-use-before-define
-        const conn = await protocolImpl.outbound(port, dst, connectionHandler);
-        if (revoked) {
-          void E(conn).close();
-        } else {
-          openConnections.add(conn);
-        }
-        return conn;
-      },
-      async revoke() {
-        revoked !== RevokeState.REVOKED ||
-          Fail`Port ${localAddr} is already revoked`;
-        revoked = RevokeState.REVOKING;
-        await E(protocolHandler).onRevoke(port, localAddr, protocolHandler);
-        revoked = RevokeState.REVOKED;
-
-        // Clean up everything we did.
-        const ps = [...currentConnections.get(port)].map(conn =>
-          E(conn)
-            .close()
-            .catch(_ => {}),
-        );
-        if (listening.has(localAddr)) {
-          const listener = listening.get(localAddr)[1];
-          ps.push(port.removeListener(listener));
-        }
-        await Promise.all(ps);
-        currentConnections.delete(port);
-        boundPorts.delete(localAddr);
-        return `Port ${localAddr} revoked`;
-      },
-    });
-
-    await E(protocolHandler).onBind(port, localAddr, protocolHandler);
-    boundPorts.init(localAddr, port);
-    currentConnections.init(port, new Set());
-    return port;
-  };
-
-  /**
-   * @type {ProtocolImpl}
-   */
-  const protocolImpl = Far('ProtocolImpl', {
-    bind,
-    async inbound(listenAddr, remoteAddr) {
-      let lastFailure = Error(`No listeners for ${listenAddr}`);
-      for await (const listenPrefix of getPrefixes(listenAddr)) {
-        if (!listening.has(listenPrefix)) {
-          continue;
-        }
-        const [port, listener] = listening.get(listenPrefix);
-        let localAddr;
-        await (async () => {
-          // See if our protocol is willing to receive this connection.
-          const localInstance = await E(protocolHandler)
-            .onInstantiate(port, listenPrefix, remoteAddr, protocolHandler)
-            .catch(rethrowUnlessMissing);
-          localAddr = localInstance
-            ? `${listenAddr}/${localInstance}`
-            : listenAddr;
-        })().catch(e => {
-          lastFailure = e;
-        });
-        if (!localAddr) {
-          continue;
-        }
-        // We have a legitimate inbound attempt.
-        let consummated;
-        const current = currentConnections.get(port);
-        const inboundAttempt = Far('InboundAttempt', {
-          getLocalAddress() {
-            // Return address metadata.
-            return localAddr;
-          },
-          getRemoteAddress() {
-            return remoteAddr;
-          },
-          async close() {
-            if (consummated) {
-              throw consummated;
-            }
-            consummated = Error(`Already closed`);
-            current.delete(inboundAttempt);
-            await E(listener)
-              .onReject(port, localAddr, remoteAddr, listener)
-              .catch(rethrowUnlessMissing);
-          },
-          async accept({
-            localAddress = localAddr,
-            remoteAddress = remoteAddr,
-            handler: rchandler,
-          }) {
-            if (consummated) {
-              throw consummated;
-            }
-            consummated = Error(`Already accepted`);
-            current.delete(inboundAttempt);
-
-            const lchandler = await E(listener).onAccept(
-              port,
-              localAddr,
-              remoteAddr,
-              listener,
-            );
-
-            return crossoverConnection(
-              lchandler,
-              localAddress,
-              rchandler,
-              remoteAddress,
-              current,
-            )[1];
-          },
-        });
-        current.add(inboundAttempt);
-        return inboundAttempt;
-      }
-      throw lastFailure;
-    },
-    async outbound(port, remoteAddr, lchandler) {
-      const localAddr =
-        /** @type {string} */
-        (await E(port).getLocalAddress());
-
-      // Allocate a local address.
-      const initialLocalInstance = await E(protocolHandler)
-        .onInstantiate(port, localAddr, remoteAddr, protocolHandler)
-        .catch(rethrowUnlessMissing);
-      const initialLocalAddr = initialLocalInstance
-        ? `${localAddr}/${initialLocalInstance}`
-        : localAddr;
-
-      let lastFailure;
-      let accepted;
-      await (async () => {
-        // Attempt the loopback connection.
-        const attempt = await protocolImpl.inbound(
-          remoteAddr,
-          initialLocalAddr,
-        );
-        accepted = await attempt.accept({ handler: lchandler });
-      })().catch(e => {
-        lastFailure = e;
-      });
-      if (accepted) {
-        return accepted;
-      }
-
-      const {
-        remoteAddress = remoteAddr,
-        handler: rchandler,
-        localAddress = localAddr,
-      } =
-        /** @type {Partial<AttemptDescription>} */
-        (
-          await E(protocolHandler).onConnect(
-            port,
-            initialLocalAddr,
-            remoteAddr,
-            lchandler,
-            protocolHandler,
-          )
-        );
-
-      if (!rchandler) {
-        throw lastFailure;
-      }
-
-      const current = currentConnections.get(port);
-      return crossoverConnection(
-        lchandler,
-        localAddress,
-        rchandler,
-        remoteAddress,
-        current,
-      )[0];
-    },
-  });
-
-  // Wire up the local protocol to the handler.
-  void E(protocolHandler).onCreate(protocolImpl, protocolHandler);
-
-  // Return the user-facing protocol.
-  return Far('binder', { bind });
-}
-
-/**
- * Create a ConnectionHandler that just echoes its packets.
- *
- * @returns {ConnectionHandler}
- */
-export function makeEchoConnectionHandler() {
-  let closed;
-  /**
-   * @type {Connection}
-   */
-  return Far('ConnectionHandler', {
-    async onReceive(_connection, bytes, _connectionHandler) {
-      if (closed) {
-        throw closed;
-      }
-      return bytes;
-    },
-    async onClose(_connection, _reason, _connectionHandler) {
-      if (closed) {
-        throw closed;
-      }
-      closed = Error('Connection closed');
-    },
-  });
-}
-
-export function makeNonceMaker(prefix = '', suffix = '') {
-  let nonce = 0;
-  return async () => {
-    nonce += 1;
-    return `${prefix}${nonce}${suffix}`;
-  };
-}
-
-/**
- * Create a protocol handler that just connects to itself.
- *
- * @param {ProtocolHandler['onInstantiate']} [onInstantiate]
- * @returns {ProtocolHandler} The localhost handler
- */
-export function makeLoopbackProtocolHandler(
-  onInstantiate = makeNonceMaker('nonce/'),
-) {
-  /**
-   * @type {MapStore<string, [Port, ListenHandler]>}
-   */
-  const listeners = makeScalarMapStore('localAddr');
-
-  const makePortID = makeNonceMaker('port');
-
-  return Far('ProtocolHandler', {
-    // eslint-disable-next-line no-empty-function
-    async onCreate(_impl, _protocolHandler) {
-      // TODO
-    },
-    async generatePortID(_protocolHandler) {
-      return makePortID();
-    },
-    async onBind(_port, _localAddr, _protocolHandler) {
-      // TODO: Maybe handle a bind?
-    },
-    async onConnect(_port, localAddr, remoteAddr, _chandler, protocolHandler) {
-      const [lport, lhandler] = listeners.get(remoteAddr);
-      const rchandler =
-        /** @type {ConnectionHandler} */
-        (await E(lhandler).onAccept(lport, remoteAddr, localAddr, lhandler));
-      // console.log(`rchandler is`, rchandler);
-      const remoteInstance = await E(protocolHandler)
-        .onInstantiate(lport, remoteAddr, localAddr, protocolHandler)
-        .catch(rethrowUnlessMissing);
-      return {
-        remoteInstance,
-        handler: rchandler,
-      };
-    },
-    onInstantiate,
-    async onListen(port, localAddr, listenHandler, _protocolHandler) {
-      // TODO: Implement other listener replacement policies.
-      if (listeners.has(localAddr)) {
-        const lhandler = listeners.get(localAddr)[1];
-        if (lhandler !== listenHandler) {
-          // Last-one-wins.
-          listeners.set(localAddr, [port, listenHandler]);
-        }
-      } else {
-        listeners.init(localAddr, [port, listenHandler]);
-      }
-    },
-    async onListenRemove(port, localAddr, listenHandler, _protocolHandler) {
-      const [lport, lhandler] = listeners.get(localAddr);
-      lport === port || Fail`Port does not match listener on ${localAddr}`;
-      lhandler === listenHandler ||
-        Fail`Listen handler does not match listener on ${localAddr}`;
-      listeners.delete(localAddr);
-    },
-    async onRevoke(_port, _localAddr, _protocolHandler) {
-      // TODO: maybe clean up?
-    },
-  });
-}

package/src/vats/network/router.js

@@ -1,115 +0,0 @@
-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/vats/network/types.js

@@ -1,85 +0,0 @@
-/**
- * @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?} 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
- */