@agoric/vats 0.15.2-dev-5676146.0 → 0.15.2-dev-e7e7c67.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/vats",
-  "version": "0.15.2-dev-5676146.0+5676146",
+  "version": "0.15.2-dev-e7e7c67.0+e7e7c67",
   "description": "Agoric's Vat library",
   "type": "module",
   "main": "./index.js",
@@ -22,18 +22,18 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-5676146.0+5676146",
-    "@agoric/ertp": "0.16.3-dev-5676146.0+5676146",
-    "@agoric/governance": "0.10.4-dev-5676146.0+5676146",
-    "@agoric/internal": "0.3.3-dev-5676146.0+5676146",
-    "@agoric/network": "0.1.1-dev-5676146.0+5676146",
-    "@agoric/notifier": "0.6.3-dev-5676146.0+5676146",
-    "@agoric/store": "0.9.3-dev-5676146.0+5676146",
-    "@agoric/swingset-vat": "0.32.3-dev-5676146.0+5676146",
-    "@agoric/time": "0.3.3-dev-5676146.0+5676146",
-    "@agoric/vat-data": "0.5.3-dev-5676146.0+5676146",
-    "@agoric/zoe": "0.26.3-dev-5676146.0+5676146",
-    "@agoric/zone": "0.2.3-dev-5676146.0+5676146",
+    "@agoric/assert": "0.6.1-dev-e7e7c67.0+e7e7c67",
+    "@agoric/ertp": "0.16.3-dev-e7e7c67.0+e7e7c67",
+    "@agoric/governance": "0.10.4-dev-e7e7c67.0+e7e7c67",
+    "@agoric/internal": "0.3.3-dev-e7e7c67.0+e7e7c67",
+    "@agoric/network": "0.1.1-dev-e7e7c67.0+e7e7c67",
+    "@agoric/notifier": "0.6.3-dev-e7e7c67.0+e7e7c67",
+    "@agoric/store": "0.9.3-dev-e7e7c67.0+e7e7c67",
+    "@agoric/swingset-vat": "0.32.3-dev-e7e7c67.0+e7e7c67",
+    "@agoric/time": "0.3.3-dev-e7e7c67.0+e7e7c67",
+    "@agoric/vat-data": "0.5.3-dev-e7e7c67.0+e7e7c67",
+    "@agoric/zoe": "0.26.3-dev-e7e7c67.0+e7e7c67",
+    "@agoric/zone": "0.2.3-dev-e7e7c67.0+e7e7c67",
     "@endo/far": "^1.0.4",
     "@endo/import-bundle": "^1.0.4",
     "@endo/marshal": "^1.3.0",
@@ -44,7 +44,7 @@
     "jessie.js": "^0.3.2"
   },
   "devDependencies": {
-    "@agoric/swingset-liveslots": "0.10.3-dev-5676146.0+5676146",
+    "@agoric/swingset-liveslots": "0.10.3-dev-e7e7c67.0+e7e7c67",
     "@endo/bundle-source": "^3.1.0",
     "@endo/init": "^1.0.4",
     "ava": "^5.3.0",
@@ -77,5 +77,5 @@
   "typeCoverage": {
     "atLeast": 89.69
   },
-  "gitHead": "5676146464043d40b6e0d2e4411440c595f20f44"
+  "gitHead": "e7e7c678d24b4b141a1b175ee8103770007fc566"
 }

package/src/ibc.d.ts

@@ -13,13 +13,14 @@ export function prepareIBCConnectionHandler(zone: import('@agoric/base-zone').Zo
     }): PromiseVow<Bytes>;
     onClose(_conn: any, _reason: any, _handler: any): Promise<void>;
 }>;
-export function prepareIBCProtocol(zone: import('@agoric/base-zone').Zone, { makeVowKit, watch, when }: ReturnType<(zone: import("@agoric/base-zone").Zone, powers?: {
+export function prepareIBCProtocol(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>;
+    allVows: (vows: any) => import("@agoric/vow").Vow<any>;
 }>): (ibcdev: any) => {
     protocolHandler: ProtocolHandler;
     bridgeHandler: BridgeHandler;
@@ -35,7 +36,7 @@ export function prepareIBCProtocol(zone: import('@agoric/base-zone').Zone, { mak
         onRevoke(_port: any, localAddr: any, _protocolHandler: any): Promise<void>;
     }>;
     bridgeHandler: import("@agoric/vats").Board<{
-        fromBridge(obj: any): Promise<void>;
+        fromBridge(obj: any): Promise<import("@agoric/vow").Vow<any> | undefined>;
     }>;
 };
 export function prepareCallbacks(zone: import('@agoric/base-zone').Zone): (dibcBridgeManager: import("@agoric/vats").ScopedBridgeManager) => import("@agoric/vats").Board<{

package/src/ibc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ibc.d.ts","sourceRoot":"","sources":["ibc.js"],"names":[],"mappings":"AAsFO,kDADK,OAAO,mBAAmB,EAAE,IAAI;;IA+CtC;;;;;;;OAOG;qBANQ,UAAU,eACV,KAAK,YACL,iBAAiB;QAEF,iBAAiB;QAC9B,WAAW,KAAK,CAAC;;GA6CnC;AAMM,yCAHI,OAAO,mBAAmB,EAAE,IAAI,+BAChC;;;;;;;EAAiD;qBAelC,eAAe;mBACjB,aAAa;;;;;;;;;;;;;;;EAuiBpC;AAKM,uCADK,OAAO,mBAAmB,EAAE,IAAI;;GAkB3C;4BAvvBa,OAAO,YAAY,EAAE,aAAa;wBAGnC,MAAM;2BAEN,MAAM;8BAEN,MAAM;;;oBAML,YAAY;iBACZ,SAAS;yBACT,YAAY;sBACZ,SAAS;;;aAgCT,MAAM;gBACN,MAAM;;;WAGN,SAAS,GAAG,WAAW;oBACvB,MAAM,EAAE;YACR,MAAM;eACN,MAAM;kBACN,YAAY;aACZ,MAAM;;yBAEP,OAAO,aAAa,EAAE,MAAM,CAAC,kBAAkB,CAAC;uBAEhD,KAAK,cAAc,EAAE,cAAc,GAAG,WAAW,CAAC,GAAG;IACjE,SAAa,EAAE,QAAQ,CAAC;IACxB,UAAc,EAAE,UAAU,CAAC;IAC3B,YAAgB,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CACnC"}
+{"version":3,"file":"ibc.d.ts","sourceRoot":"","sources":["ibc.js"],"names":[],"mappings":"AA2DO,kDADK,OAAO,mBAAmB,EAAE,IAAI;;IA+CtC;;;;;;;OAOG;qBANQ,UAAU,eACV,KAAK,YACL,iBAAiB;QAEF,iBAAiB;QAC9B,WAAW,KAAK,CAAC;;GA6CnC;AAMM,yCAHI,OAAO,mBAAmB,EAAE,IAAI,UAChC;;;;;;;;EAAiD;qBAgBlC,eAAe;mBACjB,aAAa;;;;;;;;;;;;;;;EA6lBpC;AAKM,uCADK,OAAO,mBAAmB,EAAE,IAAI;;GAkB3C;4BAnxBa,OAAO,YAAY,EAAE,aAAa;wBAGnC,MAAM;2BAEN,MAAM;8BAEN,MAAM;;;oBAML,YAAY;iBACZ,SAAS;yBACT,YAAY;sBACZ,SAAS;;;aAKT,MAAM;gBACN,MAAM;;;WAGN,SAAS,GAAG,WAAW;oBACvB,MAAM,EAAE;YACR,MAAM;eACN,MAAM;kBACN,YAAY;aACZ,MAAM;;yBAEP,OAAO,aAAa,EAAE,MAAM,CAAC,kBAAkB,CAAC;uBAEhD,KAAK,cAAc,EAAE,cAAc,GAAG,WAAW,CAAC,GAAG;IACjE,SAAa,EAAE,QAAQ,CAAC;IACxB,UAAc,EAAE,UAAU,CAAC;IAC3B,YAAgB,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CACnC"}

package/src/ibc.js

@@ -34,33 +34,6 @@ const DEFAULT_PACKET_TIMEOUT_NS = 10n * 60n * 1_000_000_000n;
  * @property {IBCPortID} destination_port
  */
 
-/** @param {import('@agoric/base-zone').Zone} zone */
-const prepareAckWatcher = zone => {
-  const makeAckWatcher = zone.exoClass(
-    'AckWatcher',
-    undefined,
-    (protocolUtils, packet) => ({ protocolUtils, packet }),
-    {
-      onFulfilled(ack) {
-        const { protocolUtils, packet } = this.state;
-
-        const realAck = ack || DEFAULT_ACKNOWLEDGEMENT;
-        const ack64 = dataToBase64(realAck);
-        protocolUtils
-          .downcall('receiveExecuted', {
-            packet,
-            ack: ack64,
-          })
-          .catch(e => this.self.onRejected(e));
-      },
-      onRejected(e) {
-        console.error(e);
-      },
-    },
-  );
-  return makeAckWatcher;
-};
-
 /**
  * @typedef {object} Counterparty
  * @property {string} port_id
@@ -187,8 +160,9 @@ export const prepareIBCConnectionHandler = zone => {
  * @param {import('@agoric/base-zone').Zone} zone
  * @param {ReturnType<import('@agoric/vow').prepareVowTools>} powers
  */
-export const prepareIBCProtocol = (zone, { makeVowKit, watch, when }) => {
-  const makeAckWatcher = prepareAckWatcher(zone);
+export const prepareIBCProtocol = (zone, powers) => {
+  const { makeVowKit, watch } = powers;
+
   const makeIBCConnectionHandler = prepareIBCConnectionHandler(zone);
 
   /**
@@ -431,14 +405,12 @@ export const prepareIBCProtocol = (zone, { makeVowKit, watch, when }) => {
             case 'channelOpenTry': {
               // They're (more or less politely) asking if we are listening, so make an attempt.
               const {
-                channelID,
                 portID,
                 counterparty: { port_id: rPortID, channel_id: rChannelID },
                 connectionHops: hops,
                 order,
                 version,
                 counterpartyVersion: rVersion,
-                asyncVersions,
               } = obj;
 
               const localAddr = `/ibc-port/${portID}/${order.toLowerCase()}/${version}`;
@@ -454,59 +426,19 @@ export const prepareIBCProtocol = (zone, { makeVowKit, watch, when }) => {
               //     e => console.warn('Manual packet', e, 'failed:', e),
               //   );
 
-              const attempt = await when(
+              return watch(
                 /** @type {ProtocolImpl} */ (protocolImpl).inbound(
                   localAddr,
                   remoteAddr,
                 ),
+                this.facets.protocolImplInboundWatcher,
+                {
+                  obj,
+                  rPortID,
+                  rChannelID,
+                  hops,
+                },
               );
-
-              // Tell what version string we negotiated.
-              const attemptedLocal = await E(attempt).getLocalAddress();
-              const match = attemptedLocal.match(
-                // Match:  ... /ORDER/VERSION ...
-                new RegExp('^(/[^/]+/[^/]+)*/(ordered|unordered)/([^/]+)(/|$)'),
-              );
-
-              const channelKey = `${channelID}:${portID}`;
-              if (!match) {
-                throw Error(
-                  `${channelKey}: cannot determine version from attempted local address ${attemptedLocal}`,
-                );
-              }
-              const negotiatedVersion = match[3];
-
-              channelKeyToAttempt.init(channelKey, attempt);
-              channelKeyToInfo.init(channelKey, obj);
-
-              try {
-                if (asyncVersions) {
-                  // We have async version negotiation, so we must call back now.
-                  await util.downcall('tryOpenExecuted', {
-                    packet: {
-                      source_port: rPortID,
-                      source_channel: rChannelID,
-                      destination_port: portID,
-                      destination_channel: channelID,
-                    },
-                    order,
-                    version: negotiatedVersion,
-                    hops,
-                  });
-                } else if (negotiatedVersion !== version) {
-                  // Too late; the other side gave us a version we didn't like.
-                  throw Error(
-                    `${channelKey}: async negotiated version was ${negotiatedVersion} but synchronous version was ${version}`,
-                  );
-                }
-              } catch (e) {
-                // Clean up after our failed attempt.
-                channelKeyToAttempt.delete(channelKey);
-                channelKeyToInfo.delete(channelKey);
-                void E(attempt).close();
-                throw e;
-              }
-              break;
             }
 
             case 'channelOpenAck': {
@@ -624,8 +556,9 @@ export const prepareIBCProtocol = (zone, { makeVowKit, watch, when }) => {
               const conn = channelKeyToConnP.get(channelKey);
               const data = base64ToBytes(data64);
 
-              watch(conn.send(data), makeAckWatcher(util, packet));
-              break;
+              return watch(conn.send(data), this.facets.ackWatcher, {
+                packet,
+              });
             }
 
             case 'acknowledgementPacket': {
@@ -735,6 +668,101 @@ export const prepareIBCProtocol = (zone, { makeVowKit, watch, when }) => {
           return kit;
         },
       },
+      ackWatcher: {
+        onFulfilled(ack, watcherContext) {
+          const { packet } = watcherContext;
+
+          const realAck = ack || DEFAULT_ACKNOWLEDGEMENT;
+          const ack64 = dataToBase64(realAck);
+          this.facets.util
+            .downcall('receiveExecuted', {
+              packet,
+              ack: ack64,
+            })
+            .catch(e => this.facets.ackWatcher.onRejected(e));
+        },
+        onRejected(e) {
+          console.log(e);
+        },
+      },
+      protocolImplAttemptWatcher: {
+        onFulfilled(attemptedLocal, watcherContext) {
+          const {
+            channelID,
+            portID,
+            attempt,
+            obj,
+            asyncVersions,
+            rPortID,
+            rChannelID,
+            order,
+            hops,
+            version,
+          } = watcherContext;
+          const { channelKeyToAttempt, channelKeyToInfo } = this.state;
+
+          const match = attemptedLocal.match(
+            // Match:  ... /ORDER/VERSION ...
+            new RegExp('^(/[^/]+/[^/]+)*/(ordered|unordered)/([^/]+)(/|$)'),
+          );
+
+          const channelKey = `${channelID}:${portID}`;
+          if (!match) {
+            throw Error(
+              `${channelKey}: cannot determine version from attempted local address ${attemptedLocal}`,
+            );
+          }
+
+          channelKeyToAttempt.init(channelKey, attempt);
+          channelKeyToInfo.init(channelKey, obj);
+
+          const negotiatedVersion = match[3];
+
+          try {
+            if (asyncVersions) {
+              // We have async version negotiation, so we must call back now.
+              return this.facets.util.downcall('tryOpenExecuted', {
+                packet: {
+                  source_port: rPortID,
+                  source_channel: rChannelID,
+                  destination_port: portID,
+                  destination_channel: channelID,
+                },
+                order,
+                version: negotiatedVersion,
+                hops,
+              });
+            } else if (negotiatedVersion !== version) {
+              // Too late; the other side gave us a version we didn't like.
+              throw Error(
+                `${channelKey}: async negotiated version was ${negotiatedVersion} but synchronous version was ${version}`,
+              );
+            }
+          } catch (e) {
+            // Clean up after our failed attempt.
+            channelKeyToAttempt.delete(channelKey);
+            channelKeyToInfo.delete(channelKey);
+            void E(attempt).close();
+            throw e;
+          }
+        },
+      },
+      protocolImplInboundWatcher: {
+        onFulfilled(attempt, watchContext) {
+          const { obj } = watchContext;
+
+          // Tell what version string we negotiated.
+          return watch(
+            E(attempt).getLocalAddress(),
+            this.facets.protocolImplAttemptWatcher,
+            {
+              ...obj,
+              ...watchContext,
+              attempt,
+            },
+          );
+        },
+      },
     },
   );
 

package/src/proposals/network-proposal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"network-proposal.d.ts","sourceRoot":"","sources":["network-proposal.js"],"names":[],"mappings":"AAiBO,+CAHI,QAAQ,GAAG,OAAO,kGAoC5B;AAqCM,gOAhBI,eAAe,GAAG;IAC5B,OAAW,EAAE;QAAE,eAAe,EAAE,UAAU,GAAG,CAAC,CAAA;KAAE,CAAC;IACjD,OAAW,EAAE;QAAE,UAAU,EAAE,SAAS,GAAG,CAAC,CAAA;KAAE,CAAC;CACxC;;oBAEqB,YAAY;gBAAU,YAAY;;kBA+E1D;AAEM;;;;;;;;;;;;;;;;;;;;;;;;;EAsBL;;;;;;;;;;;;;;;;;;;;iCApGmB,SAAS,KAAK,UAAU,YAAY,KAAK,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;sBAE5D;IACZ,OAAW,EAAE,KAAK,UAAU,CAAC,CAAC;IAC9B,GAAO,EAAE,KAAK,MAAM,CAAC,CAAC;IACtB,YAAgB,EAAE,KAAK,eAAe,GAAG,SAAS,CAAC,CAAC;CACjD"}
+{"version":3,"file":"network-proposal.d.ts","sourceRoot":"","sources":["network-proposal.js"],"names":[],"mappings":"AAiBO,+CAHI,QAAQ,GAAG,OAAO,kGAoC5B;AAqCM,gOAhBI,eAAe,GAAG;IAC5B,OAAW,EAAE;QAAE,eAAe,EAAE,UAAU,GAAG,CAAC,CAAA;KAAE,CAAC;IACjD,OAAW,EAAE;QAAE,UAAU,EAAE,SAAS,GAAG,CAAC,CAAA;KAAE,CAAC;CACxC;;oBAEqB,YAAY;gBAAU,YAAY;;kBAiF1D;AAEM;;;;;;;;;;;;;;;;;;;;;;;;;EAsBL;;;;;;;;;;;;;;;;;;;;iCAtGmB,SAAS,KAAK,UAAU,YAAY,KAAK,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;sBAE5D;IACZ,OAAW,EAAE,KAAK,UAAU,CAAC,CAAC;IAC9B,GAAO,EAAE,KAAK,MAAM,CAAC,CAAC;IACtB,YAAgB,EAAE,KAAK,eAAe,GAAG,SAAS,CAAC,CAAC;CACjD"}

package/src/proposals/network-proposal.js

@@ -5,8 +5,8 @@
 import { E } from '@endo/far';
 import { BridgeId as BRIDGE_ID } from '@agoric/internal';
 import { prepareVowTools } from '@agoric/vat-data/vow.js';
-import { makeScalarMapStore } from '@agoric/store';
 import { makeHeapZone } from '@agoric/zone';
+import { makeScalarBigMapStore } from '@agoric/vat-data';
 
 const NUM_IBC_PORTS_PER_CLIENT = 3;
 const INTERCHAIN_ACCOUNT_CONTROLLER_PORT_PREFIX = 'icacontroller-';
@@ -108,7 +108,9 @@ export const setupNetworkProtocols = async (
   // don't proceed if loadCriticalVat fails
   await Promise.all(Object.values(vats));
 
-  produceVatUpgradeInfo.resolve(makeScalarMapStore('vatUpgradeInfo'));
+  produceVatUpgradeInfo.resolve(
+    makeScalarBigMapStore('vatUpgradeInfo', { durable: true }),
+  );
   const info = await vatUpgradeInfoP;
   info.init('ibc', ibcRef);
   info.init('network', networkRef);

package/src/types.d.ts

@@ -87,13 +87,13 @@ export type NamesByAddressAdmin = NameAdmin & {
 /** An object that can receive messages from the bridge device */
 export type BridgeHandler = {
   /** Handle an inbound message */
-  fromBridge: (obj: any) => Promise<void>;
+  fromBridge: (obj: any) => PromiseVow<void>;
 };
 
 /** An object which handles messages for a specific bridge */
 export type ScopedBridgeManager = {
   toBridge: (obj: any) => Promise<any>;
-  fromBridge: (obj: any) => Promise<void>;
+  fromBridge: (obj: any) => PromiseVow<void>;
   initHandler: (handler: ERef<BridgeHandler>) => void;
   setHandler: (handler: ERef<BridgeHandler>) => void;
 };

package/src/vat-ibc.d.ts

@@ -14,7 +14,7 @@ export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
             onRevoke(_port: any, localAddr: any, _protocolHandler: any): Promise<void>;
         }>;
         bridgeHandler: import("@endo/exo/src/exo-makers.js").Guarded<{
-            fromBridge(obj: any): Promise<void>;
+            fromBridge(obj: any): Promise<import("@agoric/vow").Vow<any> | undefined>;
         }>;
     };
     makeCallbacks: (dibcBridgeManager: import("./types.js").ScopedBridgeManager) => import("@endo/exo/src/exo-makers.js").Guarded<{
@@ -36,7 +36,7 @@ export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
             onRevoke(_port: any, localAddr: any, _protocolHandler: any): Promise<void>;
         }>;
         bridgeHandler: import("@endo/exo/src/exo-makers.js").Guarded<{
-            fromBridge(obj: any): Promise<void>;
+            fromBridge(obj: any): Promise<import("@agoric/vow").Vow<any> | undefined>;
         }>;
     };
     makeCallbacks: (dibcBridgeManager: import("./types.js").ScopedBridgeManager) => import("@endo/exo/src/exo-makers.js").Guarded<{

package/src/vat-network.d.ts

@@ -1,12 +1,9 @@
 export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
-    makeLoopbackProtocolHandler: (instancePrefix?: string | undefined) => import("@endo/exo/src/exo-makers").Guarded<{
+    makeLoopbackProtocolHandler: (instancePrefix: any) => import("@endo/exo/src/exo-makers").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;
-        }>;
+        onConnect(_port: any, localAddr: any, remoteAddr: any, _chandler: any, protocolHandler: any): Promise<import("@agoric/vow").Vow<any>>;
         onInstantiate(_port: any, _localAddr: any, _remote: any, _protocol: any): Promise<string>;
         onListen(port: any, localAddr: any, listenHandler: any, _protocolHandler: any): Promise<void>;
         onListenRemove(port: Port, localAddr: string, listenHandler: ListenHandler, _protocolHandler: any): Promise<void>;
@@ -32,14 +29,11 @@ export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
     /** @param {Parameters<typeof protocol.bind>} args */
     bind: (localAddr: string) => Promise<Port | import("@agoric/vow").Vow<Port>>;
 } & import("@endo/eventual-send").RemotableBrand<{}, {
-    makeLoopbackProtocolHandler: (instancePrefix?: string | undefined) => import("@endo/exo/src/exo-makers").Guarded<{
+    makeLoopbackProtocolHandler: (instancePrefix: any) => import("@endo/exo/src/exo-makers").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;
-        }>;
+        onConnect(_port: any, localAddr: any, remoteAddr: any, _chandler: any, protocolHandler: any): Promise<import("@agoric/vow").Vow<any>>;
         onInstantiate(_port: any, _localAddr: any, _remote: any, _protocol: any): Promise<string>;
         onListen(port: any, localAddr: any, listenHandler: any, _protocolHandler: any): Promise<void>;
         onListenRemove(port: Port, localAddr: string, listenHandler: ListenHandler, _protocolHandler: any): Promise<void>;

package/src/vat-network.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vat-network.d.ts","sourceRoot":"","sources":["vat-network.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqBI,wEAAwE;;IAGxE,0EAA0E;;IAG1E,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IANrD,wEAAwE;;IAGxE,0EAA0E;;IAG1E,qDAAqD;;GAGxD"}
+{"version":3,"file":"vat-network.d.ts","sourceRoot":"","sources":["vat-network.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;IAqBI,wEAAwE;;IAGxE,0EAA0E;;IAG1E,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;IANrD,wEAAwE;;IAGxE,0EAA0E;;IAG1E,qDAAqD;;GAGxD"}