@agoric/network 0.1.1-orchestration-dev-096c4e8.0 → 0.1.1-upgrade-16-fi-dev-8879538.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-upgrade-16-fi-dev-8879538.0+8879538",
   "description": "Agoric's network protocol API",
   "type": "module",
   "main": "./src/index.js",
@@ -21,45 +21,42 @@
   "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/assert": "0.6.1-upgrade-16-fi-dev-8879538.0+8879538",
+    "@agoric/internal": "0.3.3-upgrade-16-fi-dev-8879538.0+8879538",
+    "@agoric/store": "0.9.3-upgrade-16-fi-dev-8879538.0+8879538",
+    "@agoric/vat-data": "0.5.3-upgrade-16-fi-dev-8879538.0+8879538",
+    "@endo/base64": "^1.0.5",
+    "@endo/far": "^1.1.2",
+    "@endo/patterns": "^1.4.0",
+    "@endo/promise-kit": "^1.1.2"
   },
   "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-upgrade-16-fi-dev-8879538.0+8879538",
+    "@agoric/swingset-vat": "0.32.3-upgrade-16-fi-dev-8879538.0+8879538",
+    "@agoric/vow": "0.1.1-upgrade-16-fi-dev-8879538.0+8879538",
+    "@agoric/zone": "0.2.3-upgrade-16-fi-dev-8879538.0+8879538",
+    "@endo/bundle-source": "^3.2.3",
     "ava": "^5.3.0",
-    "c8": "^7.13.0"
+    "c8": "^9.1.0"
   },
   "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 +65,7 @@
     "workerThreads": false
   },
   "typeCoverage": {
-    "atLeast": 76.57
+    "atLeast": 89.39
   },
-  "gitHead": "096c4e8fce80e9a509b0e1a30fda11736c4570e1"
+  "gitHead": "8879538cd1d125a08346f02dd5701d0d70c90bb8"
 }

package/src/bytes.d.ts

@@ -1,29 +1,31 @@
 /**
- * Convert some data to bytes.
+ * 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): string;
 /**
  * Convert bytes to a String.
  *
  * @param {Bytes} bytes
  * @returns {string}
  */
-export function bytesToString(bytes: Bytes): string;
+export function bytesToString(bytes: string): 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 dataToBase64(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 function base64ToBytes(string: string): string;
+export type ByteSource = string | Iterable<number> | Buffer | Uint8Array;
 //# 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":"AAgCA;;;;;;GAMG;AACH,oCAHW,UAAU,UAQpB;AAED;;;;;GAKG;AACH,8CAFa,MAAM,CAIlB;AAED;;;;;GAKG;AACH,yCAHW,UAAU,GACR,MAAM,CAKlB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,UAKhB"}

package/src/bytes.js

@@ -1,25 +1,47 @@
+// @ts-check
 /// <reference path="./types.js" />
+import { Fail } from '@agoric/assert';
 import { encodeBase64, decodeBase64 } from '@endo/base64';
 
-/* eslint-disable no-bitwise */
 /**
- * Convert some data to bytes.
- *
- * @param {Data} data
- * @returns {Bytes}
+ * @import {Bytes} from './types.js';
+ */
+
+/** @typedef {Bytes | Buffer | Uint8Array | Iterable<number>} ByteSource */
+
+/**
+ * @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 +57,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 dataToBase64(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

@@ -10,137 +10,113 @@ export function getPrefixes(addr: string): string[];
  * @param {import('@agoric/base-zone').Zone} zone
  * @param {ReturnType<import('@agoric/vow').prepareVowTools>} powers
  */
-export function prepareLoopbackProtocolHandler(zone: import('@agoric/base-zone').Zone, { when }: ReturnType<(zone: import("@agoric/base-zone").Zone, powers?: {
+export function prepareLoopbackProtocolHandler(zone: import("@agoric/base-zone").Zone, { watch, allVows }: 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>;
+    when: <T, TResult1 = import("@agoric/vow").Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").Unwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
+    watch: <T_1 = unknown, TResult1_1 = T_1, TResult2_1 = T_1, C = unknown>(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?: C | undefined) => 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<{
+    allVows: (vows: any) => import("@agoric/vow").Vow<any>;
+}>): (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: string, remoteAddr: string): 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 {import('@agoric/vow').Remote<Port>} port
      * @param {Endpoint} localAddr
-     * @param {ListenHandler} listenHandler
+     * @param {import('@agoric/vow').Remote<ListenHandler>} listenHandler
      * @param {*} _protocolHandler
      */
-    onListenRemove(port: Port, localAddr: Endpoint, listenHandler: ListenHandler, _protocolHandler: any): Promise<void>;
+    onListenRemove(port: import("@agoric/vow").Remote<Port, never>, localAddr: string, listenHandler: import("@agoric/vow").Remote<ListenHandler, never>, _protocolHandler: any): Promise<void>;
     onRevoke(_port: any, _localAddr: any, _protocolHandler: any): Promise<void>;
 }>;
+/**
+ * @import {AttemptDescription, Bytes, Closable, CloseReason, Connection, ConnectionHandler, Endpoint, ListenHandler, Port, Protocol, ProtocolHandler, ProtocolImpl} from './types.js';
+ */
 /**
  * Compatibility note: this must match what our peers use, so don't change it
  * 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 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?: {
+export function crossoverConnection(zone: import("@agoric/zone").Zone, handler0: import("@agoric/vow").Remote<Required<ConnectionHandler>, never>, addr0: string, handler1: import("@agoric/vow").Remote<Required<ConnectionHandler>, never>, addr1: string, makeConnection: (opts: ConnectionOpts) => Connection, current?: globalThis.WeakSetStore<Closable> | undefined): 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>;
+    when: <T, TResult1 = import("@agoric/vow").Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").Unwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
+    watch: <T_1 = unknown, TResult1_1 = T_1, TResult2_1 = T_1, C = unknown>(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?: C | undefined) => 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<{
+    allVows: (vows: any) => import("@agoric/vow").Vow<any>;
+}>): (protocolHandler: import("@agoric/vow").Remote<ProtocolHandler, never>) => Protocol;
+export function prepareEchoConnectionKit(zone: import("@agoric/base-zone").Zone): () => import("@endo/exo").GuardedKit<{
     handler: {
         /**
          * @param {Connection} _connection
          * @param {Bytes} bytes
          * @param {ConnectionHandler} _connectionHandler
          */
-        onReceive(_connection: Connection, bytes: Bytes, _connectionHandler: ConnectionHandler): Promise<string>;
+        onReceive(_connection: Connection, bytes: string, _connectionHandler: ConnectionHandler): Promise<string>;
         /**
          * @param {Connection} _connection
          * @param {CloseReason} [_reason]
          * @param {ConnectionHandler} [_connectionHandler]
          */
-        onClose(_connection: Connection, _reason?: CloseReason, _connectionHandler?: ConnectionHandler | undefined): Promise<void>;
+        onClose(_connection: Connection, _reason?: any, _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
              * @param {ConnectionHandler} _connectionHandler
              */
-            onReceive(_connection: Connection, bytes: Bytes, _connectionHandler: ConnectionHandler): Promise<string>;
+            onReceive(_connection: Connection, bytes: string, _connectionHandler: ConnectionHandler): Promise<string>;
             /**
              * @param {Connection} _connection
              * @param {CloseReason} [_reason]
              * @param {ConnectionHandler} [_connectionHandler]
              */
-            onClose(_connection: Connection, _reason?: CloseReason, _connectionHandler?: ConnectionHandler | undefined): Promise<void>;
+            onClose(_connection: Connection, _reason?: any, _connectionHandler?: ConnectionHandler | undefined): Promise<void>;
         }>>;
         onListen(port: any, _listenHandler: any): Promise<void>;
     };
 }>;
+export function preparePortAllocator(zone: import("@agoric/base-zone").Zone, { watch }: ReturnType<(zone: import("@agoric/base-zone").Zone, powers?: {
+    isRetryableReason?: ((reason: any) => boolean) | undefined;
+} | undefined) => {
+    when: <T, TResult1 = import("@agoric/vow").Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").Unwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
+    watch: <T_1 = unknown, TResult1_1 = T_1, TResult2_1 = T_1, C = unknown>(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?: C | undefined) => import("@agoric/vow").Vow<TResult1_1 | TResult2_1>;
+    makeVowKit: <T_2>() => import("@agoric/vow").VowKit<T_2>;
+    allVows: (vows: any) => import("@agoric/vow").Vow<any>;
+}>): (args_0?: any) => import("@endo/exo").Guarded<{
+    allocateCustomIBCPort(specifiedName?: string): import("@agoric/vow").Vow<any>;
+    allocateICAControllerPort(): import("@agoric/vow").Vow<any>;
+    allocateICQControllerPort(): import("@agoric/vow").Vow<any>;
+    allocateCustomLocalPort(specifiedName?: string): import("@agoric/vow").Vow<any>;
+}>;
 export type ConnectionOpts = {
-    addrs: Endpoint[];
-    handlers: ConnectionHandler[];
-    conns: MapStore<number, Connection>;
-    current: WeakSetStore<Closable>;
+    addrs: string[];
+    handlers: import("@agoric/vow").Remote<Required<ConnectionHandler>, never>[];
+    conns: globalThis.MapStore<number, Connection>;
+    current: globalThis.WeakSetStore<Closable>;
     l: 0 | 1;
     r: 0 | 1;
 };
+import type { AttemptDescription } from './types.js';
+import type { Port } from './types.js';
+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';
 //# 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":"AAkCA;;;;GAIG;AACH,kCAFW,MAAM,YAahB;AA0tCD;;;;;GAKG;AACH,qDAHW,OAAO,mBAAmB,EAAE,IAAI,sBAChC,UAAU;;;uFApwCoG,CAAC;;;;EAowC9D;;;;IAmCpD;;;;;OAKG;;;;IAgEH;;;;;OAKG;;;GA8CV;AAh6CD;;GAEG;AAEH;;;GAGG;AACH,qCAAsC;AAG/B,0CADK,OAAO,aAWlB;AAyJM,0CARI,OAAO,cAAc,EAAE,IAAI,+MAKpB,cAAc,wFAgD/B;AAi7BM,6CAHI,OAAO,mBAAmB,EAAE,IAAI,UAChC,UAAU;;;;;;;EAAuC,uFAkC3D;AAOM,+CAFI,OAAO,mBAAmB,EAAE,IAAI;;QAsCnC;;;;WAIG;;QASH;;;;WAIG;;;;;YAjBH;;;;eAIG;;YASH;;;;eAIG;;;;;GAuBV;AAwKM,2CAHI,OAAO,mBAAmB,EAAE,IAAI,aAChC,UAAU;;;;;;;EAAuC;;;;;GA+DzD;;;;;;OAv6CW,CAAC,GAAC,CAAC;OACH,CAAC,GAAC,CAAC;;wCA7DyJ,YAAY;0BAAZ,YAAY;mCAAZ,YAAY;uCAAZ,YAAY;gCAAZ,YAAY;8BAAZ,YAAY;qCAAZ,YAAY;8BAAZ,YAAY"}