@agoric/network 0.1.1-orchestration-dev-096c4e8.0 → 0.1.1-other-dev-3eb1a1d.0

package/README.md

@@ -57,15 +57,12 @@ E(home.ibcport[0]).connect(remoteEndpoint, connectionHandler)
 
 The other side of `connect()` is a "listening port". These ports are waiting for inbound connections to be established.
 
-To get a listening port, you need a `NetworkInterface` object (such as the one on your `ag-solo` under `home.network`) and ask it to `bind()` to an endpoint. You can either provide a specific port name, or allow the API to allocate a random one for you. The endpoint specifies the type of connection that this port will be able to accept (IBC, TCP, etc), and some properties of that connection. `bind()` uses a "multiaddress" to encode this information.
+To get a listening port, you need a `NetworkInterface` object (such as the one on your `ag-solo` under `home.network`) and ask it for a port, via the `PortAllocator`.
 
 ```js
 // ask for a random allocation - ends with a slash
-E(home.network).bind('/ibc-port/')
-  .then(port => usePort(port));
-
-// or ask for a specific port name
-E(home.network).bind('/ibc-port/my-cool-port-name')
+E(home.network).getPortAllocator()
+  .then(portAllocator => E(portAllocator).allocateCustomIBCPort())
   .then(port => usePort(port));
 ```
 
@@ -147,7 +144,7 @@ Note that if you want to listen on this port again, you can just call `port.addL
 
 ### Closing the Port Entirely
 
-Removing a listener doesn't release the port address to make it available for other `bind()` requests.  You can call:
+Removing a listener doesn't release the port address to make it available for other `PortAllocator` requests.  You can call:
 
 ```js
 port.revoke();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/network",
-  "version": "0.1.1-orchestration-dev-096c4e8.0+096c4e8",
+  "version": "0.1.1-other-dev-3eb1a1d.0+3eb1a1d",
   "description": "Agoric's network protocol API",
   "type": "module",
   "main": "./src/index.js",
@@ -8,9 +8,9 @@
   "scripts": {
     "build": "exit 0",
     "prepack": "tsc --build tsconfig.build.json",
-    "postpack": "git clean -f '*.d.ts*'",
+    "postpack": "git clean -f '*.d.ts*' '*.tsbuildinfo'",
     "test": "ava",
-    "test:c8": "c8 $C8_OPTIONS ava",
+    "test:c8": "c8 --all $C8_OPTIONS ava",
     "test:xs": "exit 0",
     "lint-fix": "yarn lint:eslint --fix",
     "lint": "run-s --continue-on-error lint:*",
@@ -21,45 +21,43 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/assert": "0.6.1-orchestration-dev-096c4e8.0+096c4e8",
-    "@agoric/internal": "0.3.3-orchestration-dev-096c4e8.0+096c4e8",
-    "@agoric/store": "0.9.3-orchestration-dev-096c4e8.0+096c4e8",
-    "@agoric/vat-data": "0.5.3-orchestration-dev-096c4e8.0+096c4e8",
-    "@endo/base64": "^1.0.2",
-    "@endo/far": "^1.0.4",
-    "@endo/patterns": "^1.1.0",
-    "@endo/promise-kit": "^1.0.4"
+    "@agoric/internal": "0.3.3-other-dev-3eb1a1d.0+3eb1a1d",
+    "@agoric/store": "0.9.3-other-dev-3eb1a1d.0+3eb1a1d",
+    "@agoric/vat-data": "0.5.3-other-dev-3eb1a1d.0+3eb1a1d",
+    "@endo/base64": "^1.0.9",
+    "@endo/errors": "^1.2.8",
+    "@endo/far": "^1.1.9",
+    "@endo/pass-style": "^1.4.7",
+    "@endo/patterns": "^1.4.7",
+    "@endo/promise-kit": "^1.1.8"
   },
   "devDependencies": {
-    "@agoric/swingset-liveslots": "0.10.3-orchestration-dev-096c4e8.0+096c4e8",
-    "@agoric/swingset-vat": "0.32.3-orchestration-dev-096c4e8.0+096c4e8",
-    "@agoric/zone": "0.2.3-orchestration-dev-096c4e8.0+096c4e8",
-    "@endo/bundle-source": "^3.1.0",
+    "@agoric/swingset-liveslots": "0.10.3-other-dev-3eb1a1d.0+3eb1a1d",
+    "@agoric/swingset-vat": "0.32.3-other-dev-3eb1a1d.0+3eb1a1d",
+    "@agoric/vow": "0.1.1-other-dev-3eb1a1d.0+3eb1a1d",
+    "@agoric/zone": "0.2.3-other-dev-3eb1a1d.0+3eb1a1d",
+    "@endo/bundle-source": "^3.5.0",
     "ava": "^5.3.0",
-    "c8": "^7.13.0"
+    "c8": "^10.1.2"
   },
   "exports": {
-    ".": "./src/index.js",
-    "./exported.js": "./exported.js"
+    ".": "./src/index.js"
   },
   "files": [
     "CHANGELOG.md",
     "src/",
     "scripts/",
-    "tools/",
-    "*.json",
-    "globals.d.ts",
-    "exported.js"
+    "tools/"
   ],
   "publishConfig": {
     "access": "public"
   },
   "engines": {
-    "node": ">=14.15.0"
+    "node": "^18.12 || ^20.9"
   },
   "ava": {
     "files": [
-      "test/**/test-*.js"
+      "test/**/*.test.*"
     ],
     "require": [
       "@endo/init/debug.js"
@@ -68,7 +66,7 @@
     "workerThreads": false
   },
   "typeCoverage": {
-    "atLeast": 76.57
+    "atLeast": 91.16
   },
-  "gitHead": "096c4e8fce80e9a509b0e1a30fda11736c4570e1"
+  "gitHead": "3eb1a1d2d75b2b4a94807cd3bf759bc9fc531f05"
 }

package/src/bytes.d.ts

@@ -1,10 +1,24 @@
 /**
- * Convert some data to bytes.
+ * @import {Bytes} from './types.js';
+ */
+/** @typedef {Bytes | Buffer | Uint8Array | Iterable<number>} ByteSource */
+/**
+ * This function is a coercer instead of an asserter because in a future where
+ * binary data has better support across vats and potentially its own type, we
+ * might allow more `specimen`s than just `ByteSource`.
+ *
+ * @param {unknown} specimen
+ * @returns {ByteSource}
+ */
+export function coerceToByteSource(specimen: unknown): ByteSource;
+/**
+ * Convert a Uint8Array or other sequence of octets to a string representation
+ * that `@endo/marshal` accepts as Passable.
  *
- * @param {Data} data
+ * @param {ByteSource} byteSource
  * @returns {Bytes}
  */
-export function toBytes(data: Data): Bytes;
+export function toBytes(byteSource: ByteSource): Bytes;
 /**
  * Convert bytes to a String.
  *
@@ -15,15 +29,18 @@ export function bytesToString(bytes: Bytes): string;
 /**
  * Base64, as specified in https://tools.ietf.org/html/rfc4648#section-4
  *
- * @param {Data} data
+ * @param {ByteSource} byteSource
  * @returns {string} base64 encoding
  */
-export function dataToBase64(data: Data): string;
+export function byteSourceToBase64(byteSource: ByteSource): string;
 /**
- * Decodes a string into base64.
+ * Decodes a base64 string into bytes.
  *
  * @param {string} string Base64-encoded string
  * @returns {Bytes} decoded bytes
  */
 export function base64ToBytes(string: string): Bytes;
+export type ByteSource = Bytes | Buffer | Uint8Array | Iterable<number>;
+import type { Bytes } from './types.js';
+import type { Bytes as Bytes_1 } from './types.js';
 //# sourceMappingURL=bytes.d.ts.map

package/src/bytes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["bytes.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,8BAHW,IAAI,GACF,KAAK,CAcjB;AAED;;;;;GAKG;AACH,qCAHW,KAAK,GACH,MAAM,CAIlB;AAED;;;;;GAKG;AACH,mCAHW,IAAI,GACF,MAAM,CAclB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,GACJ,KAAK,CAIjB"}
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["bytes.js"],"names":[],"mappings":"AAKA;;GAEG;AAEH,2EAA2E;AAE3E;;;;;;;GAOG;AACH,6CAHW,OAAO,GACL,UAAU,CAgBtB;AAuBD;;;;;;GAMG;AACH,oCAHW,UAAU,GACR,KAAK,CAOjB;AAED;;;;;GAKG;AACH,qCAHW,KAAK,GACH,MAAM,CAIlB;AAED;;;;;GAKG;AACH,+CAHW,UAAU,GACR,MAAM,CAKlB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,GACJ,KAAK,CAIjB;yBA1Fa,KAAK,GAAG,MAAM,GAAG,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC;2BAHpC,YAAY;sCAAZ,YAAY"}

package/src/bytes.js

@@ -1,25 +1,71 @@
-/// <reference path="./types.js" />
+// @ts-check
+import { X, Fail } from '@endo/errors';
 import { encodeBase64, decodeBase64 } from '@endo/base64';
+import { isObject } from '@endo/pass-style';
 
-/* eslint-disable no-bitwise */
 /**
- * Convert some data to bytes.
+ * @import {Bytes} from './types.js';
+ */
+
+/** @typedef {Bytes | Buffer | Uint8Array | Iterable<number>} ByteSource */
+
+/**
+ * This function is a coercer instead of an asserter because in a future where
+ * binary data has better support across vats and potentially its own type, we
+ * might allow more `specimen`s than just `ByteSource`.
  *
- * @param {Data} data
- * @returns {Bytes}
+ * @param {unknown} specimen
+ * @returns {ByteSource}
+ */
+export function coerceToByteSource(specimen) {
+  if (typeof specimen === 'string') {
+    return specimen;
+  }
+
+  isObject(specimen) ||
+    assert.fail(X`non-object ${specimen} is not a ByteSource`, TypeError);
+
+  const obj = /** @type {{}} */ (specimen);
+  typeof obj[Symbol.iterator] === 'function' ||
+    assert.fail(X`non-iterable ${specimen} is not a ByteSource`, TypeError);
+
+  // Good enough... it's iterable and can be converted later.
+  return /** @type {ByteSource} */ (specimen);
+}
+
+/**
+ * @param {ByteSource} contents
  */
-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));
+const coerceToByteArray = contents => {
+  if (typeof contents === 'string') {
+    return Uint8Array.from(contents, c => {
+      const b = c.charCodeAt(0);
+      b <= 0xff || Fail`character cannot be coerced to an octet: ${c}`;
+      return b;
+    });
+  } else if (contents instanceof Uint8Array) {
+    // Reconstruct to ensure we have a Uint8Array and not a Buffer.
+    return new Uint8Array(
+      contents.buffer,
+      contents.byteOffset,
+      contents.byteLength,
+    );
   }
+  return new Uint8Array(contents);
+};
 
+/**
+ * Convert a Uint8Array or other sequence of octets to a string representation
+ * that `@endo/marshal` accepts as Passable.
+ *
+ * @param {ByteSource} byteSource
+ * @returns {Bytes}
+ */
+export function toBytes(byteSource) {
   // 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);
+  const buf = coerceToByteArray(byteSource);
+  return String.fromCharCode(...buf);
 }
 
 /**
@@ -35,25 +81,16 @@ export function bytesToString(bytes) {
 /**
  * Base64, as specified in https://tools.ietf.org/html/rfc4648#section-4
  *
- * @param {Data} data
+ * @param {ByteSource} byteSource
  * @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);
-  }
+export function byteSourceToBase64(byteSource) {
+  const bytes = coerceToByteArray(byteSource);
   return encodeBase64(bytes);
 }
 
 /**
- * Decodes a string into base64.
+ * Decodes a base64 string into bytes.
  *
  * @param {string} string Base64-encoded string
  * @returns {Bytes} decoded bytes

package/src/index.d.ts

@@ -1,5 +1,7 @@
 export * from "./network.js";
+export * from "./shapes.js";
 export * from "./multiaddr.js";
 export * from "./bytes.js";
+export * from "./types.js";
 export { prepareRouter, prepareRouterProtocol } from "./router.js";
 //# sourceMappingURL=index.d.ts.map

package/src/index.js

@@ -1,4 +1,7 @@
 export * from './network.js';
+export * from './shapes.js';
 export { prepareRouter, prepareRouterProtocol } from './router.js';
 export * from './multiaddr.js';
 export * from './bytes.js';
+// eslint-disable-next-line import/export -- doesn't know types
+export * from './types.js';

package/src/multiaddr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiaddr.d.ts","sourceRoot":"","sources":["multiaddr.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;;GAKG;AACH,0BAHW,QAAQ,aA2BlB;AAED;;;;;GAKG;AACH,4BAHW,YAAY,QAAQ,GAClB,QAAQ,CAQpB;;;;;;;;;;;;;;;;;;;;;;wBAlDY,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE;;;;;uBAElB,MAAM"}
+{"version":3,"file":"multiaddr.d.ts","sourceRoot":"","sources":["multiaddr.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;;GAKG;AACH,0BAHW,QAAQ,GACN,SAAS,CA0BrB;AAED;;;;;GAKG;AACH,4BAHW,SAAS,GAAG,QAAQ,GAClB,QAAQ,CAQpB;;;;;;;;;;;;;;;;;;;;;;wBAlDY,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE;;;;;uBAElB,MAAM"}

package/src/network.d.ts

@@ -4,36 +4,33 @@
  * @param {string} addr
  */
 export function getPrefixes(addr: string): string[];
+/** @typedef {ReturnType<typeof prepareEchoConnectionKit>} MakeEchoConnectionKit */
 /**
  * Create a protocol handler that just connects to itself.
  *
  * @param {import('@agoric/base-zone').Zone} zone
- * @param {ReturnType<import('@agoric/vow').prepareVowTools>} powers
+ * @param {VowTools} powers
  */
-export function prepareLoopbackProtocolHandler(zone: import('@agoric/base-zone').Zone, { when }: ReturnType<(zone: import("@agoric/base-zone").Zone, powers?: {
-    isRetryableReason?: ((reason: any) => boolean) | undefined;
-    watchPromise?: ((p: PromiseLike<any>, watcher: import("@agoric/vow/src/watch-promise.js").PromiseWatcher, ...args: unknown[]) => void) | undefined;
-} | undefined) => {
-    when: <T = any, TResult1 = import("@agoric/vow/src/E.js").Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow/src/E.js").Unwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
-    watch: <T_1 = any, TResult1_1 = T_1, TResult2_1 = T_1>(specimenP: import("@agoric/vow").ERef<T_1 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: unknown) => import("@agoric/vow").Vow<TResult1_1 | TResult2_1>;
-    makeVowKit: <T_2>() => import("@agoric/vow").VowKit<T_2>;
-}>): (instancePrefix?: string | undefined) => import("@endo/exo/src/exo-makers.js").Guarded<{
+export function prepareLoopbackProtocolHandler(zone: import("@agoric/base-zone").Zone, { watch, allVows }: VowTools): (instancePrefix?: string | undefined) => import("@endo/exo").Guarded<{
     onCreate(_impl: any, _protocolHandler: any): Promise<void>;
     generatePortID(_localAddr: any, _protocolHandler: any): Promise<string>;
     onBind(_port: any, _localAddr: any, _protocolHandler: any): Promise<void>;
-    onConnect(_port: any, localAddr: any, remoteAddr: any, _chandler: any, protocolHandler: any): Promise<{
-        remoteInstance: any;
-        handler: ConnectionHandler;
-    }>;
+    /**
+     * @param {*} _port
+     * @param {Endpoint} localAddr
+     * @param {Endpoint} remoteAddr
+     * @returns {import('@agoric/vow').PromiseVow<AttemptDescription>}}
+     */
+    onConnect(_port: any, localAddr: Endpoint, remoteAddr: Endpoint): import("@agoric/vow").PromiseVow<AttemptDescription>;
     onInstantiate(_port: any, _localAddr: any, _remote: any, _protocol: any): Promise<string>;
     onListen(port: any, localAddr: any, listenHandler: any, _protocolHandler: any): Promise<void>;
     /**
-     * @param {Port} port
+     * @param {Remote<Port>} port
      * @param {Endpoint} localAddr
-     * @param {ListenHandler} listenHandler
+     * @param {Remote<ListenHandler>} listenHandler
      * @param {*} _protocolHandler
      */
-    onListenRemove(port: Port, localAddr: Endpoint, listenHandler: ListenHandler, _protocolHandler: any): Promise<void>;
+    onListenRemove(port: Remote<Port>, localAddr: Endpoint, listenHandler: Remote<ListenHandler>, _protocolHandler: any): Promise<void>;
     onRevoke(_port: any, _localAddr: any, _protocolHandler: any): Promise<void>;
 }>;
 /**
@@ -41,68 +38,11 @@ export function prepareLoopbackProtocolHandler(zone: import('@agoric/base-zone')
  * casually.
  */
 export const ENDPOINT_SEPARATOR: "/";
-export namespace Shape {
-    let ConnectionI: import("@endo/patterns").InterfaceGuard<{
-        send: import("@endo/patterns").MethodGuard;
-        close: import("@endo/patterns").MethodGuard;
-        getLocalAddress: import("@endo/patterns").MethodGuard;
-        getRemoteAddress: import("@endo/patterns").MethodGuard;
-    }>;
-    let InboundAttemptI: import("@endo/patterns").InterfaceGuard<{
-        accept: import("@endo/patterns").MethodGuard;
-        getLocalAddress: import("@endo/patterns").MethodGuard;
-        getRemoteAddress: import("@endo/patterns").MethodGuard;
-        close: import("@endo/patterns").MethodGuard;
-    }>;
-    let PortI: import("@endo/patterns").InterfaceGuard<{
-        getLocalAddress: import("@endo/patterns").MethodGuard;
-        addListener: import("@endo/patterns").MethodGuard;
-        connect: import("@endo/patterns").MethodGuard;
-        removeListener: import("@endo/patterns").MethodGuard;
-        revoke: import("@endo/patterns").MethodGuard;
-    }>;
-    let ProtocolHandlerI: import("@endo/patterns").InterfaceGuard<{
-        onCreate: import("@endo/patterns").MethodGuard;
-        generatePortID: import("@endo/patterns").MethodGuard;
-        onBind: import("@endo/patterns").MethodGuard;
-        onListen: import("@endo/patterns").MethodGuard;
-        onListenRemove: import("@endo/patterns").MethodGuard;
-        onInstantiate: import("@endo/patterns").MethodGuard;
-        onConnect: import("@endo/patterns").MethodGuard;
-        onRevoke: import("@endo/patterns").MethodGuard;
-    }>;
-    let ProtocolImplI: import("@endo/patterns").InterfaceGuard<{
-        bind: import("@endo/patterns").MethodGuard;
-        inbound: import("@endo/patterns").MethodGuard;
-        outbound: import("@endo/patterns").MethodGuard;
-    }>;
-    function Vow$(shape: any): import("@endo/patterns").Matcher;
-    let AttemptDescription: import("@endo/patterns").Matcher;
-    let Opts: import("@endo/patterns").Matcher;
-    let Data: import("@endo/patterns").Matcher;
-    let Bytes: import("@endo/patterns").Matcher;
-    let Endpoint: import("@endo/patterns").Matcher;
-    let Vow: import("@endo/patterns").Matcher;
-    let ConnectionHandler: import("@endo/patterns").Matcher;
-    let Connection: import("@endo/patterns").Matcher;
-    let InboundAttempt: import("@endo/patterns").Matcher;
-    let Listener: import("@endo/patterns").Matcher;
-    let ListenHandler: import("@endo/patterns").Matcher;
-    let Port: import("@endo/patterns").Matcher;
-    let ProtocolHandler: import("@endo/patterns").Matcher;
-    let ProtocolImpl: import("@endo/patterns").Matcher;
-}
+export const CLOSE_REASON_FINALIZER: "closed-by-finalizer";
 export function rethrowUnlessMissing(err: unknown): undefined;
-export function crossoverConnection(zone: import('@agoric/zone').Zone, handler0: ConnectionHandler, addr0: Endpoint, handler1: ConnectionHandler, addr1: Endpoint, makeConnection: (opts: ConnectionOpts) => Connection, current?: WeakSetStore<Closable>): Connection[];
-export function prepareNetworkProtocol(zone: import('@agoric/base-zone').Zone, powers: ReturnType<(zone: import("@agoric/base-zone").Zone, powers?: {
-    isRetryableReason?: ((reason: any) => boolean) | undefined;
-    watchPromise?: ((p: PromiseLike<any>, watcher: import("@agoric/vow/src/watch-promise.js").PromiseWatcher, ...args: unknown[]) => void) | undefined;
-} | undefined) => {
-    when: <T = any, TResult1 = import("@agoric/vow/src/E.js").Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow/src/E.js").Unwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
-    watch: <T_1 = any, TResult1_1 = T_1, TResult2_1 = T_1>(specimenP: import("@agoric/vow").ERef<T_1 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: unknown) => import("@agoric/vow").Vow<TResult1_1 | TResult2_1>;
-    makeVowKit: <T_2>() => import("@agoric/vow").VowKit<T_2>;
-}>): (protocolHandler: ProtocolHandler) => Protocol;
-export function prepareEchoConnectionKit(zone: import('@agoric/base-zone').Zone): () => import("@endo/exo/src/exo-makers.js").GuardedKit<{
+export function crossoverConnection(zone: import("@agoric/zone").Zone, handler0: Remote<Required<ConnectionHandler>>, addr0: Endpoint, handler1: Remote<Required<ConnectionHandler>>, addr1: Endpoint, makeConnection: (opts: ConnectionOpts) => Connection, finalizer: Finalizer, current?: globalThis.WeakSetStore<Closable> | undefined): Connection[];
+export function prepareNetworkProtocol(zone: import("@agoric/base-zone").Zone, powers: Powers): (protocolHandler: Remote<ProtocolHandler>) => Protocol;
+export function prepareEchoConnectionKit(zone: import("@agoric/base-zone").Zone): () => import("@endo/exo").GuardedKit<{
     handler: {
         /**
          * @param {Connection} _connection
@@ -112,13 +52,13 @@ export function prepareEchoConnectionKit(zone: import('@agoric/base-zone').Zone)
         onReceive(_connection: Connection, bytes: Bytes, _connectionHandler: ConnectionHandler): Promise<string>;
         /**
          * @param {Connection} _connection
-         * @param {CloseReason} [_reason]
+         * @param {CloseReason} [reason]
          * @param {ConnectionHandler} [_connectionHandler]
          */
-        onClose(_connection: Connection, _reason?: CloseReason, _connectionHandler?: ConnectionHandler | undefined): Promise<void>;
+        onClose(_connection: Connection, reason?: CloseReason, _connectionHandler?: ConnectionHandler | undefined): Promise<void>;
     };
     listener: {
-        onAccept(_port: any, _localAddr: any, _remoteAddr: any, _listenHandler: any): Promise<import("@endo/exo/src/exo-makers.js").Guarded<{
+        onAccept(_port: any, _localAddr: any, _remoteAddr: any, _listenHandler: any): Promise<import("@endo/exo").Guarded<{
             /**
              * @param {Connection} _connection
              * @param {Bytes} bytes
@@ -127,20 +67,82 @@ export function prepareEchoConnectionKit(zone: import('@agoric/base-zone').Zone)
             onReceive(_connection: Connection, bytes: Bytes, _connectionHandler: ConnectionHandler): Promise<string>;
             /**
              * @param {Connection} _connection
-             * @param {CloseReason} [_reason]
+             * @param {CloseReason} [reason]
              * @param {ConnectionHandler} [_connectionHandler]
              */
-            onClose(_connection: Connection, _reason?: CloseReason, _connectionHandler?: ConnectionHandler | undefined): Promise<void>;
+            onClose(_connection: Connection, reason?: CloseReason, _connectionHandler?: ConnectionHandler | undefined): Promise<void>;
         }>>;
         onListen(port: any, _listenHandler: any): Promise<void>;
     };
 }>;
+export function preparePortAllocator(zone: import("@agoric/base-zone").Zone, { watch }: Powers): (args_0: {
+    protocol: Protocol;
+}) => import("@endo/exo").Guarded<{
+    allocateCustomIBCPort(specifiedName?: string): Promise<import("@agoric/vow").Vow<Port>>;
+    allocateICAControllerPort(): Promise<import("@agoric/vow").Vow<Port>>;
+    allocateICQControllerPort(): Promise<import("@agoric/vow").Vow<Port>>;
+    allocateCustomLocalPort(specifiedName?: string): Promise<import("@agoric/vow").Vow<Port>>;
+}>;
+export function prepareNetworkPowers(zone: import("@agoric/base-zone").Zone, vowTools: VowTools): Powers;
+export type MakeEchoConnectionKit = ReturnType<typeof prepareEchoConnectionKit>;
+export type Powers = VowTools & {
+    finalizer: Finalizer;
+};
 export type ConnectionOpts = {
     addrs: Endpoint[];
-    handlers: ConnectionHandler[];
+    handlers: Remote<Required<ConnectionHandler>>[];
     conns: MapStore<number, Connection>;
     current: WeakSetStore<Closable>;
     l: 0 | 1;
     r: 0 | 1;
 };
+export type PortAllocator = ReturnType<ReturnType<typeof preparePortAllocator>>;
+export type Finalizer = ReturnType<typeof prepareFinalizer>;
+import type { VowTools } from '@agoric/vow';
+import type { Endpoint } from './types.js';
+import type { AttemptDescription } from './types.js';
+import type { Port } from './types.js';
+import type { Remote } from '@agoric/vow';
+import type { ListenHandler } from './types.js';
+import type { ConnectionHandler } from './types.js';
+import type { Connection } from './types.js';
+import type { Closable } from './types.js';
+import type { ProtocolHandler } from './types.js';
+import type { Protocol } from './types.js';
+import type { Bytes } from './types.js';
+import type { CloseReason } from './types.js';
+/** @typedef {ReturnType<ReturnType<typeof preparePortAllocator>>} PortAllocator */
+/**
+ * Return a package-specific singleton that pins objects until they are
+ * explicitly unpinned or finalized.  It needs to pin objects only because they
+ * are resources that need to be released.
+ *
+ * The reason this functionality wasn't just baked into the other network exos
+ * is to maintain upgrade-compatible with minimal additional changes.
+ *
+ * @param {import('@agoric/base-zone').Zone} zone
+ * @param {VowTools} vowTools
+ */
+declare function prepareFinalizer(zone: import("@agoric/base-zone").Zone, { watch }: VowTools): import("@endo/exo").Guarded<{
+    has(obj: any): boolean;
+    /**
+     * Add a connection and handler for an `onClose` method to be called upon
+     * finalization.
+     * @param {Remote<Connection>} conn
+     * @param {Remote<Required<ConnectionHandler>>} handler
+     */
+    initConnection(conn: Remote<Connection>, handler: Remote<Required<ConnectionHandler>>): void;
+    /**
+     * Add an object with a `close` method to be called (such as an
+     * `inboundAttempt`) upon finalization.
+     * @param {Remote<{ close(): PromiseVow<any> }>} closer
+     */
+    initCloser(closer: Remote<{
+        close(): PromiseVow<any>;
+    }>): void;
+    finalize(obj: any): import("@agoric/vow").Vow<any> | undefined;
+    unpin(obj: any): void;
+}>;
+import type { PromiseVow } from '@agoric/vow';
+export {};
 //# sourceMappingURL=network.d.ts.map

package/src/network.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["network.js"],"names":[],"mappings":"AAyJA;;;;GAIG;AACH,kCAFW,MAAM,YAahB;AAgvBD;;;;;GAKG;AACH,qDAHW,OAAO,mBAAmB,EAAE,IAAI,YAChC;;;;;;;EAAiD;;;;;;;;;;IA4EtD;;;;;OAKG;yBAJQ,IAAI,aACJ,QAAQ,iBACR,aAAa;;GAkB7B;AAn/BD;;;GAGG;AACH,qCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA8B9B,4DAAgC;;;;;;;;;;;;;;;;AAgGjC,0CADK,OAAO,aAWlB;AA2GM,0CARI,OAAO,cAAc,EAAE,IAAI,YAC3B,iBAAiB,SACjB,QAAQ,YACR,iBAAiB,SACjB,QAAQ,yBACD,cAAc,KAAK,UAAU,YACpC,aAAa,QAAQ,CAAC,gBA+ChC;AAofM,6CAHI,OAAO,mBAAmB,EAAE,IAAI,UAChC;;;;;;;EAAiD,qBAM/C,eAAe,KACb,QAAQ,CA2BtB;AAOM,+CAFI,OAAO,mBAAmB,EAAE,IAAI;;QAuCnC;;;;WAIG;+BAHQ,UAAU,SACV,KAAK,sBACL,iBAAiB;QAU5B;;;;WAIG;6BAHQ,UAAU,YACV,WAAW;;;;YAftB;;;;eAIG;mCAHQ,UAAU,SACV,KAAK,sBACL,iBAAiB;YAU5B;;;;eAIG;iCAHQ,UAAU,YACV,WAAW;;;;GAyB7B;;WA1uBa,QAAQ,EAAE;cACV,iBAAiB,EAAE;WACnB,SAAS,MAAM,EAAE,UAAU,CAAC;aAC5B,aAAa,QAAQ,CAAC;OACtB,CAAC,GAAC,CAAC;OACH,CAAC,GAAC,CAAC"}
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["network.js"],"names":[],"mappings":"AA2CA;;;;GAIG;AACH,kCAFW,MAAM,YAahB;AAwtCD,mFAAmF;AAEnF;;;;;GAKG;AACH,qDAHW,OAAO,mBAAmB,EAAE,IAAI,sBAChC,QAAQ;;;;IAmCX;;;;;OAKG;qBAJQ,GAAC,aACD,QAAQ,cACR,QAAQ,GACN,OAAO,aAAa,EAAE,UAAU,CAAC,kBAAkB,CAAC;;;IA+DjE;;;;;OAKG;yBAJQ,OAAO,IAAI,CAAC,aACZ,QAAQ,iBACR,OAAO,aAAa,CAAC,oBACrB,GAAC;;GA+CnB;AA75CD;;;GAGG;AACH,qCAAsC;AAGtC,2DAA4D;AAGrD,0CADK,OAAO,aAWlB;AA4JM,0CATI,OAAO,cAAc,EAAE,IAAI,YAC3B,OAAO,QAAQ,CAAC,iBAAiB,CAAC,CAAC,SACnC,QAAQ,YACR,OAAO,QAAQ,CAAC,iBAAiB,CAAC,CAAC,SACnC,QAAQ,kBACR,CAAC,IAAI,EAAE,cAAc,KAAK,UAAU,aACpC,SAAS,yEAqDnB;AAw6BM,6CAHI,OAAO,mBAAmB,EAAE,IAAI,UAChC,MAAM,qBAMJ,OAAO,eAAe,CAAC,KACrB,QAAQ,CA2BtB;AAOM,+CAFI,OAAO,mBAAmB,EAAE,IAAI;;QAsCnC;;;;WAIG;+BAHQ,UAAU,SACV,KAAK,sBACL,iBAAiB;QAU5B;;;;WAIG;6BAHQ,UAAU,WACV,WAAW;;;;YAftB;;;;eAIG;mCAHQ,UAAU,SACV,KAAK,sBACL,iBAAiB;YAU5B;;;;eAIG;iCAHQ,UAAU,WACV,WAAW;;;;GAyB7B;AAuKM,2CAHI,OAAO,mBAAmB,EAAE,IAAI,aAChC,MAAM;cAkBF,QAAQ;;;;;;GAkDpB;AAwEI,2CAJI,OAAO,mBAAmB,EAAE,IAAI,YAChC,QAAQ,GACN,MAAM,CAKlB;oCAnTa,UAAU,CAAC,OAAO,wBAAwB,CAAC;qBAnwC3C,QAAQ,GAAG;IAAE,SAAS,EAAE,SAAS,CAAA;CAAE;;WA6DnC,QAAQ,EAAE;cACV,OAAO,QAAQ,CAAC,iBAAiB,CAAC,CAAC,EAAE;WACrC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;aAC5B,YAAY,CAAC,QAAQ,CAAC;OACtB,CAAC,GAAC,CAAC;OACH,CAAC,GAAC,CAAC;;4BA06CH,UAAU,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;wBA4EnD,UAAU,CAAC,OAAO,gBAAgB,CAAC;8BA3jDF,aAAa;8BAD8G,YAAY;wCAAZ,YAAY;0BAAZ,YAAY;4BACvI,aAAa;mCAD8G,YAAY;uCAAZ,YAAY;gCAAZ,YAAY;8BAAZ,YAAY;qCAAZ,YAAY;8BAAZ,YAAY;2BAAZ,YAAY;iCAAZ,YAAY;AAg/CtL,mFAAmF;AAEnF;;;;;;;;;;GAUG;AACH,wCAHW,OAAO,mBAAmB,EAAE,IAAI,aAChC,QAAQ;;IAcf;;;;;OAKG;yBAFQ,OAAO,UAAU,CAAC,WAClB,OAAO,QAAQ,CAAC,iBAAiB,CAAC,CAAC;IAK9C;;;;OAIG;uBADQ,OAAO;QAAE,KAAK,IAAI,WAAW,GAAG,CAAC,CAAA;KAAE,CAAC;;;GA0BlD;gCA9iD8C,aAAa"}