@agoric/vats 0.15.2-dev-7ffae88.0 → 0.15.2-dev-c5284e4.0

package/src/proposals/localchain-test.d.ts

@@ -0,0 +1,25 @@
+export function testLocalChain({ consume: { chainStorage, localchain } }: BootstrapPowers & {
+    consume: {
+        localchain: import('../localchain.js').LocalChain;
+    };
+}, { options: { testResultPath } }: {
+    options: {
+        testResultPath: string;
+    };
+}): Promise<void>;
+export function getManifestForLocalChainTest(_powers: any, { testResultPath }: {
+    testResultPath: any;
+}): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                chainStorage: string;
+                localchain: string;
+            };
+        };
+    };
+    options: {
+        testResultPath: any;
+    };
+};
+//# sourceMappingURL=localchain-test.d.ts.map

package/src/proposals/localchain-test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localchain-test.d.ts","sourceRoot":"","sources":["localchain-test.js"],"names":[],"mappings":"AAYO,0EARI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,UAAgB,EAAE,OAAO,kBAAkB,EAAE,UAAU,CAAC;KACnD,CAAC;CACH;IAE2C,OAAO,EAA3C;QAAE,cAAc,EAAE,MAAM,CAAA;KAAE;kBAwDpC;AAEM;;;;;;;;;;;;;;EAYL"}

package/src/proposals/localchain-test.js

@@ -0,0 +1,81 @@
+// @ts-check
+import { E } from '@endo/far';
+
+/**
+ * @param {BootstrapPowers & {
+ *   consume: {
+ *     localchain: import('../localchain.js').LocalChain;
+ *   };
+ * }} powers
+ * @param {object} options
+ * @param {{ testResultPath: string }} options.options
+ */
+export const testLocalChain = async (
+  { consume: { chainStorage, localchain } },
+  { options: { testResultPath } },
+) => {
+  console.warn('=== localchain test started (result in', testResultPath, ')!');
+  /** @type {null | ERef<StorageNode>} */
+  let node = await chainStorage;
+  if (!node) {
+    throw new Error('no chainStorage');
+  }
+
+  for (const nodeName of testResultPath.split('.')) {
+    node = E(node).makeChildNode(nodeName);
+  }
+
+  let result;
+  try {
+    const lca = await E(localchain).createAccount();
+    console.info('created account', lca);
+    const address = await E(lca).getAddress();
+    console.info('address', address);
+    const balances = await E(lca).allBalances();
+    console.info('balances', balances);
+    await E(lca)
+      .executeTx([
+        {
+          '@type': '/cosmos.bank.v1beta1.MsgSend',
+          from_address: address,
+          to_address: address,
+          amount: [{ denom: 'ucosm', amount: '1' }],
+        },
+      ])
+      .then(
+        res => console.info('unexpected executeTx result', res),
+        e => {
+          if (String(e).match(/insufficient funds/)) {
+            console.info('insufficient funds as expected');
+            return;
+          }
+          console.info('unexpected error', e);
+        },
+      );
+
+    const emptyQuery = await E(localchain).query([]);
+    console.info('emptyQuery', emptyQuery);
+
+    result = { success: true };
+  } catch (e) {
+    console.error('test failed with', e);
+    result = { success: false, error: String(e) };
+  }
+
+  console.warn('=== localchain test done, setting', { result });
+  await E(node).setValue(JSON.stringify(result));
+};
+
+export const getManifestForLocalChainTest = (_powers, { testResultPath }) => ({
+  manifest: {
+    [testLocalChain.name]: {
+      consume: {
+        chainStorage: 'bridge',
+        localchain: 'localchain',
+      },
+    },
+  },
+  options: {
+    testResultPath,
+  },
+});

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

@@ -1,5 +1,5 @@
 export function registerNetworkProtocols(vats: SoloVats | NetVats, dibcBridgeManager?: ERef<import("../types.js").ScopedBridgeManager> | undefined): Promise<void>;
-export function setupNetworkProtocols({ consume: { client, loadCriticalVat, bridgeManager: bridgeManagerP, provisioning, }, produce: { networkVat }, }: BootstrapPowers & {
+export function setupNetworkProtocols({ consume: { client, loadCriticalVat, bridgeManager: bridgeManagerP, provisioning, vatUpgradeInfo: vatUpgradeInfoP, }, produce: { networkVat, vatUpgradeInfo: produceVatUpgradeInfo }, }: BootstrapPowers & {
     consume: {
         loadCriticalVat: VatLoader<any>;
     };
@@ -24,10 +24,13 @@ export function getManifestForNetwork(_powers: any, { networkRef, ibcRef }: {
                 bridgeManager: string;
                 zoe: string;
                 provisioning: string;
+                vatUpgradeInfo: boolean;
             };
             produce: {
                 networkVat: string;
+                vatUpgradeInfo: boolean;
             };
+            zone: boolean;
         };
     };
     options: {
@@ -35,7 +38,45 @@ export function getManifestForNetwork(_powers: any, { networkRef, ibcRef }: {
         ibcRef: any;
     };
 };
+/**
+ * Create the network and IBC vats; produce `networkVat` in the core / bootstrap
+ * space.
+ *
+ * The `networkVat` is CLOSELY HELD in the core space, where later, we claim
+ * ports using `E(networkVat).bind(_path_)`. As discussed in `ProtocolHandler`
+ * docs, _path_ is:
+ *
+ * - /ibc-port/NAME for an IBC port with a known name or,
+ * - /ibc-port/ for an IBC port with a fresh name.
+ *
+ * Contracts are expected to use the services of the network and IBC vats by way
+ * of such ports.
+ *
+ * Testing facilities include:
+ *
+ * - loopback ports: `E(networkVat).bind('/local/')`
+ * - an echo port: `E(vats.network).bind('/ibc-port/echo')`
+ */
 export type VatLoader2 = ((name: 'network') => NetworkVat) & ((name: 'ibc') => IBCVat);
+/**
+ * Create the network and IBC vats; produce `networkVat` in the core / bootstrap
+ * space.
+ *
+ * The `networkVat` is CLOSELY HELD in the core space, where later, we claim
+ * ports using `E(networkVat).bind(_path_)`. As discussed in `ProtocolHandler`
+ * docs, _path_ is:
+ *
+ * - /ibc-port/NAME for an IBC port with a known name or,
+ * - /ibc-port/ for an IBC port with a fresh name.
+ *
+ * Contracts are expected to use the services of the network and IBC vats by way
+ * of such ports.
+ *
+ * Testing facilities include:
+ *
+ * - loopback ports: `E(networkVat).bind('/local/')`
+ * - an echo port: `E(vats.network).bind('/ibc-port/echo')`
+ */
 export type NetVats = {
     network: ERef<NetworkVat>;
     ibc: ERef<IBCVat>;

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

@@ -1 +1 @@
-{"version":3,"file":"network-proposal.d.ts","sourceRoot":"","sources":["network-proposal.js"],"names":[],"mappings":"AAeO,+CAHI,QAAQ,GAAG,OAAO,kGA2D5B;AAmBM,wJAhBI,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+D1D;AAEM;;;;;;;;;;;;;;;;;;;;;;EAmBL;iCAjFmB,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;;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"}

package/src/proposals/network-proposal.js

@@ -1,10 +1,12 @@
-import { E, Far } from '@endo/far';
+/**
+ * @file CoreEval module to set up network, IBC vats.
+ * @see {setupNetworkProtocols}
+ */
+import { E } from '@endo/far';
 import { BridgeId as BRIDGE_ID } from '@agoric/internal';
-import {
-  makeLoopbackProtocolHandler,
-  makeEchoConnectionHandler,
-  makeNonceMaker,
-} from '@agoric/network';
+import { prepareVowTools } from '@agoric/vat-data/vow.js';
+import { makeScalarMapStore } from '@agoric/store';
+import { makeHeapZone } from '@agoric/zone';
 
 const NUM_IBC_PORTS_PER_CLIENT = 3;
 const INTERCHAIN_ACCOUNT_CONTROLLER_PORT_PREFIX = 'icacontroller-';
@@ -15,63 +17,58 @@ const INTERCHAIN_ACCOUNT_CONTROLLER_PORT_PREFIX = 'icacontroller-';
  */
 export const registerNetworkProtocols = async (vats, dibcBridgeManager) => {
   const ps = [];
+
+  const loopbackHandler = await E(vats.network).makeLoopbackProtocolHandler();
   // Every vat has a loopback device.
-  ps.push(
-    E(vats.network).registerProtocolHandler(
-      ['/local'],
-      makeLoopbackProtocolHandler(),
-    ),
-  );
+  ps.push(E(vats.network).registerProtocolHandler(['/local'], loopbackHandler));
+
   if (dibcBridgeManager) {
     assert('ibc' in vats);
     // We have access to the bridge, and therefore IBC.
-    const callbacks = Far('callbacks', {
-      downcall(method, obj) {
-        return E(dibcBridgeManager).toBridge({
-          ...obj,
-          type: 'IBC_METHOD',
-          method,
-        });
-      },
-    });
+    const settledBridgeManager = await dibcBridgeManager;
+    const callbacks = await E(vats.ibc).makeCallbacks(settledBridgeManager);
     ps.push(
       E(vats.ibc)
-        .createInstance(callbacks)
-        .then(ibcHandler =>
+        .createHandlers(callbacks)
+        .then(({ protocolHandler, bridgeHandler }) =>
           E(dibcBridgeManager)
-            .initHandler(ibcHandler)
+            .initHandler(bridgeHandler)
             .then(() =>
               E(vats.network).registerProtocolHandler(
                 ['/ibc-port', '/ibc-hop'],
-                ibcHandler,
+                protocolHandler,
               ),
             ),
         ),
     );
   } else {
-    const loHandler = makeLoopbackProtocolHandler(
-      makeNonceMaker('ibc-channel/channel-'),
+    const loHandler = await E(vats.network).makeLoopbackProtocolHandler(
+      'ibc-channel/channel-',
     );
     ps.push(E(vats.network).registerProtocolHandler(['/ibc-port'], loHandler));
   }
   await Promise.all(ps);
-
-  // Add an echo listener on our ibc-port network (whether real or virtual).
-  const echoPort = await E(vats.network).bind('/ibc-port/echo');
-
-  return E(echoPort).addListener(
-    Far('listener', {
-      async onAccept(_port, _localAddr, _remoteAddr, _listenHandler) {
-        return harden(makeEchoConnectionHandler());
-      },
-      async onListen(port, _listenHandler) {
-        console.debug(`listening on echo port: ${port}`);
-      },
-    }),
-  );
 };
 
 /**
+ * Create the network and IBC vats; produce `networkVat` in the core / bootstrap
+ * space.
+ *
+ * The `networkVat` is CLOSELY HELD in the core space, where later, we claim
+ * ports using `E(networkVat).bind(_path_)`. As discussed in `ProtocolHandler`
+ * docs, _path_ is:
+ *
+ * - /ibc-port/NAME for an IBC port with a known name or,
+ * - /ibc-port/ for an IBC port with a fresh name.
+ *
+ * Contracts are expected to use the services of the network and IBC vats by way
+ * of such ports.
+ *
+ * Testing facilities include:
+ *
+ * - loopback ports: `E(networkVat).bind('/local/')`
+ * - an echo port: `E(vats.network).bind('/ibc-port/echo')`
+ *
  * @param {BootstrapPowers & {
  *   consume: { loadCriticalVat: VatLoader<any> };
  *   produce: { networkVat: Producer<any> };
@@ -95,8 +92,9 @@ export const setupNetworkProtocols = async (
       loadCriticalVat,
       bridgeManager: bridgeManagerP,
       provisioning,
+      vatUpgradeInfo: vatUpgradeInfoP,
     },
-    produce: { networkVat },
+    produce: { networkVat, vatUpgradeInfo: produceVatUpgradeInfo },
   },
   options,
 ) => {
@@ -110,6 +108,11 @@ export const setupNetworkProtocols = async (
   // don't proceed if loadCriticalVat fails
   await Promise.all(Object.values(vats));
 
+  produceVatUpgradeInfo.resolve(makeScalarMapStore('vatUpgradeInfo'));
+  const info = await vatUpgradeInfoP;
+  info.init('ibc', ibcRef);
+  info.init('network', networkRef);
+
   networkVat.reset();
   networkVat.resolve(vats.network);
   const bridgeManager = await bridgeManagerP;
@@ -139,6 +142,16 @@ export const setupNetworkProtocols = async (
   // we need to finish registering handlers for
   // ibc-port etc.
   await registerNetworkProtocols(vats, dibcBridgeManager);
+
+  // Heap-based vow resolution is used for this module because the
+  // bootstrap vat can't yet be upgraded.
+  const powers = prepareVowTools(makeHeapZone());
+
+  const { when } = powers;
+  // Add an echo listener on our ibc-port network (whether real or virtual).
+  const echoPort = await when(E(vats.network).bind('/ibc-port/echo'));
+  const { listener } = await E(vats.network).makeEchoConnectionKit();
+  await E(echoPort).addListener(listener);
   return E(client).assignBundle([_a => ({ ibcport: makePorts() })]);
 };
 
@@ -151,10 +164,13 @@ export const getManifestForNetwork = (_powers, { networkRef, ibcRef }) => ({
         bridgeManager: 'bridge',
         zoe: 'zoe',
         provisioning: 'provisioning',
+        vatUpgradeInfo: true,
       },
       produce: {
         networkVat: 'network',
+        vatUpgradeInfo: true,
       },
+      zone: true,
     },
   },
   options: {

package/src/proposals/probeZcfBundle.d.ts

@@ -0,0 +1,26 @@
+export function probeZcfBundleCap({ consume: { vatAdminSvc, walletFactoryStartResult, provisionPoolStartResult, chainStorage, walletBridgeManager: walletBridgeManagerP, vatStore, }, }: {
+    consume: {
+        vatAdminSvc: any;
+        walletFactoryStartResult: any;
+        provisionPoolStartResult: any;
+        chainStorage: any;
+        walletBridgeManager: any;
+        vatStore: any;
+    };
+}, options: any): Promise<void>;
+export function getManifestForProbeZcfBundleCap(_powers: any, options: any): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                vatAdminSvc: boolean;
+                vatStore: boolean;
+                walletBridgeManager: boolean;
+                walletFactoryStartResult: boolean;
+                provisionPoolStartResult: boolean;
+                chainStorage: boolean;
+            };
+        };
+    };
+    options: any;
+};
+//# sourceMappingURL=probeZcfBundle.d.ts.map

package/src/proposals/probeZcfBundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"probeZcfBundle.d.ts","sourceRoot":"","sources":["probeZcfBundle.js"],"names":[],"mappings":"AAIO;;;;;;;;;gCAiDN;AAGM;;;;;;;;;;;;;;EAcL"}

package/src/proposals/probeZcfBundle.js

@@ -0,0 +1,72 @@
+import { E } from '@endo/far';
+import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
+
+// verify that Zoe remembers the zcfBundleCap across upgrades
+export const probeZcfBundleCap = async (
+  {
+    consume: {
+      vatAdminSvc,
+      walletFactoryStartResult,
+      provisionPoolStartResult,
+      chainStorage,
+      walletBridgeManager: walletBridgeManagerP,
+      vatStore,
+    },
+  },
+  options,
+) => {
+  const { zoeRef, zcfRef, walletRef } = options.options;
+
+  const { adminNode, root: zoeRoot } = await E(vatStore).get('zoe');
+  const zoeConfigFacet = await E(zoeRoot).getZoeConfigFacet();
+
+  // STEP 1: restart WF; it'll use the newest ZCF known to Zoe ////////////////
+
+  const WALLET_STORAGE_PATH_SEGMENT = 'wallet';
+  const [walletBridgeManager, walletStorageNode, ppFacets] = await Promise.all([
+    walletBridgeManagerP,
+    makeStorageNodeChild(chainStorage, WALLET_STORAGE_PATH_SEGMENT),
+    provisionPoolStartResult,
+  ]);
+  const walletReviver = await E(ppFacets.creatorFacet).getWalletReviver();
+  const privateArgs = {
+    storageNode: walletStorageNode,
+    walletBridgeManager,
+    walletReviver,
+  };
+
+  const { adminFacet: walletAdminFacet } = await walletFactoryStartResult;
+  await E(walletAdminFacet).upgradeContract(walletRef.bundleID, privateArgs);
+
+  // STEP 2: Set the ZCF bundle ////////////////////////
+  await E(zoeConfigFacet).updateZcfBundleId(zcfRef.bundleID);
+
+  // STEP 3: Upgrade Zoe again ////////////////////////
+  // //////  See if Zoe forgets ZcfBundleCap //////////
+
+  const zoeBundleCap = await E(vatAdminSvc).getBundleCap(zoeRef.bundleID);
+  await E(adminNode).upgrade(zoeBundleCap, {});
+
+  // STEP 4: restart WF ////////////////////////
+  await E(walletAdminFacet).restartContract(privateArgs);
+
+  // //////  See which zcf bundle was used //////////
+};
+harden(probeZcfBundleCap);
+
+export const getManifestForProbeZcfBundleCap = (_powers, options) => ({
+  manifest: {
+    [probeZcfBundleCap.name]: {
+      consume: {
+        vatAdminSvc: true,
+        vatStore: true,
+        walletBridgeManager: true,
+        walletFactoryStartResult: true,
+        provisionPoolStartResult: true,
+        chainStorage: true,
+      },
+    },
+  },
+  options,
+});
+harden(getManifestForProbeZcfBundleCap);

package/src/proposals/restart-vats-proposal.d.ts

@@ -13,6 +13,8 @@ export function getManifestForRestart(_powers: any, options: any): {
                 loadCriticalVat: boolean;
                 psmKit: boolean;
                 vatStore: boolean;
+                vatAdminSvc: boolean;
+                vatUpgradeInfo: boolean;
                 zoe: string;
                 provisioning: string;
                 vaultFactoryKit: boolean;

package/src/proposals/restart-vats-proposal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"restart-vats-proposal.d.ts","sourceRoot":"","sources":["restart-vats-proposal.js"],"names":[],"mappings":"AA6BO,yCALI,eAAe,GACzB,OAAW,wDAAwD,EAAE,qBAAqB;IAErD,OAAO,EAAlC;QAAE,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE;kBA0G5B;AAGM;;;;;;;;;;;;;;;;;;EAkBL"}
+{"version":3,"file":"restart-vats-proposal.d.ts","sourceRoot":"","sources":["restart-vats-proposal.js"],"names":[],"mappings":"AA+BO,yCALI,eAAe,GACzB,OAAW,wDAAwD,EAAE,qBAAqB;IAErD,OAAO,EAAlC;QAAE,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE;kBAkH5B;AAGM;;;;;;;;;;;;;;;;;;;;EAoBL"}

package/src/proposals/restart-vats-proposal.js

@@ -16,6 +16,8 @@ const vatUpgradeStatus = {
   bank: 'covered by test-upgrade-vats: upgrade vat-bank',
   board: 'covered by test-upgrade-vats: upgrade vat-board',
   bridge: 'covered by test-upgrade-vats: upgrade vat-bridge',
+  ibc: 'upgradeable',
+  network: 'upgradeable',
   priceAuthority: 'covered by test-upgrade-vats: upgrade vat-priceAuthority',
   provisioning: 'UNTESTED',
   zoe: 'tested in @agoric/zoe',
@@ -117,11 +119,19 @@ export const restartVats = async ({ consume }, { options }) => {
   }
 
   trace('iterating over vatStore');
-  for (const [name] of vatStore.entries()) {
+  for (const [name, { adminNode }] of vatStore.entries()) {
     const status = vatUpgradeStatus[name];
     if (!status) {
       Fail`unaudited vat ${name}`;
     }
+    if (status === 'upgradeable') {
+      console.log('upgrading vat', name);
+      const { vatAdminSvc } = consume;
+      const info = await consume.vatUpgradeInfo;
+      const { bundleID } = info.get(name);
+      const bcap = await E(vatAdminSvc).getBundleCap(bundleID);
+      await E(adminNode).upgrade(bcap);
+    }
     console.log('VAT', name, status);
   }
 
@@ -144,6 +154,8 @@ export const getManifestForRestart = (_powers, options) => ({
         loadCriticalVat: true,
         psmKit: true,
         vatStore: true,
+        vatAdminSvc: true,
+        vatUpgradeInfo: true,
         zoe: 'zoe',
         provisioning: 'provisioning',
         vaultFactoryKit: true,

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

@@ -1 +1 @@
-{"version":3,"file":"zcf-proposal.d.ts","sourceRoot":"","sources":["zcf-proposal.js"],"names":[],"mappings":"AAeO,mEAZI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,WAAiB,EAAE,WAAW,CAAC;QAC/B,QAAc,EAAE,SAChB,MAAc,EACd,OAAe,sBAAsB,EAAE,gBAAgB,CAChD,CAAC;KACH,CAAC;CACH;;gBAEiB,YAAY;gBAAU,YAAY;;kBAmBtD;AAEM;;;;;;;;;;;;;;;;;EAcL"}
+{"version":3,"file":"zcf-proposal.d.ts","sourceRoot":"","sources":["zcf-proposal.js"],"names":[],"mappings":"AAgBO,mEAZI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,WAAiB,EAAE,WAAW,CAAC;QAC/B,QAAc,EAAE,SAChB,MAAc,EACd,OAAe,sBAAsB,EAAE,gBAAgB,CAChD,CAAC;KACH,CAAC;CACH;;gBAEiB,YAAY;gBAAU,YAAY;;kBAmBtD;AAEM;;;;;;;;;;;;;;;;;EAcL"}

package/src/proposals/zcf-proposal.js

@@ -1,3 +1,4 @@
+// @ts-check
 import { E } from '@endo/far';
 
 /**

package/src/vat-bridge.d.ts

@@ -1,8 +1,22 @@
 export function buildRootObject(vatPowers: any, _args: any, baggage: any): {
-    makeBridgedChainStorageRoot: (storageBridgeManagerP: ERef<import('./types.js').ScopedBridgeManager>, rootPath: string, options?: object) => Promise<any>;
+    makeBridgedChainStorageRoot: (storageBridgeManagerP: ERef<import('./types.js').ScopedBridgeManager>, rootPath: string, options?: object) => Promise<import("@endo/exo/src/exo-makers.js").Guarded<{
+        getPath(): string;
+        getStoreKey(): Promise<import("@agoric/internal/src/lib-chainStorage.js").VStorageKey>;
+        makeChildNode(name: string, childNodeOptions?: {
+            sequence?: boolean | undefined;
+        } | undefined): import("@agoric/internal/src/lib-chainStorage.js").StorageNode;
+        setValue(value: string): Promise<void>;
+    }>>;
     provideManagerForBridge: (bridgeDevice: BridgeDevice) => import("./types.js").BridgeManager;
 } & import("@endo/eventual-send").RemotableBrand<{}, {
-    makeBridgedChainStorageRoot: (storageBridgeManagerP: ERef<import('./types.js').ScopedBridgeManager>, rootPath: string, options?: object) => Promise<any>;
+    makeBridgedChainStorageRoot: (storageBridgeManagerP: ERef<import('./types.js').ScopedBridgeManager>, rootPath: string, options?: object) => Promise<import("@endo/exo/src/exo-makers.js").Guarded<{
+        getPath(): string;
+        getStoreKey(): Promise<import("@agoric/internal/src/lib-chainStorage.js").VStorageKey>;
+        makeChildNode(name: string, childNodeOptions?: {
+            sequence?: boolean | undefined;
+        } | undefined): import("@agoric/internal/src/lib-chainStorage.js").StorageNode;
+        setValue(value: string): Promise<void>;
+    }>>;
     provideManagerForBridge: (bridgeDevice: BridgeDevice) => import("./types.js").BridgeManager;
 }>;
 //# sourceMappingURL=vat-bridge.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"vat-bridge.d.ts","sourceRoot":"","sources":["vat-bridge.js"],"names":[],"mappings":"AAOA;yDAea,KAAK,OAAO,YAAY,EAAE,mBAAmB,CAAC,YAC9C,MAAM,YACN,MAAM;;;yDAFN,KAAK,OAAO,YAAY,EAAE,mBAAmB,CAAC,YAC9C,MAAM,YACN,MAAM;;GAyBlB"}
+{"version":3,"file":"vat-bridge.d.ts","sourceRoot":"","sources":["vat-bridge.js"],"names":[],"mappings":"AAOA;yDAea,KAAK,OAAO,YAAY,EAAE,mBAAmB,CAAC,YAC9C,MAAM,YACN,MAAM;;;;;;;;;;yDAFN,KAAK,OAAO,YAAY,EAAE,mBAAmB,CAAC,YAC9C,MAAM,YACN,MAAM;;;;;;;;;GAyBlB"}

package/src/vat-ibc.d.ts

@@ -1,6 +1,46 @@
-export function buildRootObject(): {
-    createInstance: (callbacks: any) => ProtocolHandler & import("./types.js").BridgeHandler;
+export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
+    createHandlers: (callbacks: any) => {
+        protocolHandler: ProtocolHandler;
+        bridgeHandler: import("./types.js").BridgeHandler;
+    } | {
+        protocolHandler: import("@endo/exo/src/exo-makers.js").Guarded<{
+            onCreate(impl: any, _protocolHandler: any): Promise<void>;
+            onInstantiate(): Promise<string>;
+            generatePortID(_localAddr: any, _protocolHandler: any): Promise<string>;
+            onBind(port: any, localAddr: any, _protocolHandler: any): Promise<any>;
+            onConnect(port: any, localAddr: any, remoteAddr: any, _chandler: any, _protocolHandler: any): Promise<import("@agoric/vow").Vow<any>>;
+            onListen(_port: any, localAddr: any, _listenHandler: any): Promise<void>;
+            onListenRemove(_port: any, localAddr: any, _listenHandler: any): Promise<void>;
+            onRevoke(_port: any, localAddr: any, _protocolHandler: any): Promise<void>;
+        }>;
+        bridgeHandler: import("@endo/exo/src/exo-makers.js").Guarded<{
+            fromBridge(obj: any): Promise<void>;
+        }>;
+    };
+    makeCallbacks: (dibcBridgeManager: import("./types.js").ScopedBridgeManager) => import("@endo/exo/src/exo-makers.js").Guarded<{
+        downcall(method: any, obj: any): Promise<any>;
+    }>;
 } & import("@endo/eventual-send").RemotableBrand<{}, {
-    createInstance: (callbacks: any) => ProtocolHandler & import("./types.js").BridgeHandler;
+    createHandlers: (callbacks: any) => {
+        protocolHandler: ProtocolHandler;
+        bridgeHandler: import("./types.js").BridgeHandler;
+    } | {
+        protocolHandler: import("@endo/exo/src/exo-makers.js").Guarded<{
+            onCreate(impl: any, _protocolHandler: any): Promise<void>;
+            onInstantiate(): Promise<string>;
+            generatePortID(_localAddr: any, _protocolHandler: any): Promise<string>;
+            onBind(port: any, localAddr: any, _protocolHandler: any): Promise<any>;
+            onConnect(port: any, localAddr: any, remoteAddr: any, _chandler: any, _protocolHandler: any): Promise<import("@agoric/vow").Vow<any>>;
+            onListen(_port: any, localAddr: any, _listenHandler: any): Promise<void>;
+            onListenRemove(_port: any, localAddr: any, _listenHandler: any): Promise<void>;
+            onRevoke(_port: any, localAddr: any, _protocolHandler: any): Promise<void>;
+        }>;
+        bridgeHandler: import("@endo/exo/src/exo-makers.js").Guarded<{
+            fromBridge(obj: any): Promise<void>;
+        }>;
+    };
+    makeCallbacks: (dibcBridgeManager: import("./types.js").ScopedBridgeManager) => import("@endo/exo/src/exo-makers.js").Guarded<{
+        downcall(method: any, obj: any): Promise<any>;
+    }>;
 }>;
 //# sourceMappingURL=vat-ibc.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"vat-ibc.d.ts","sourceRoot":"","sources":["vat-ibc.js"],"names":[],"mappings":"AAGA;;;;GAUC"}
+{"version":3,"file":"vat-ibc.d.ts","sourceRoot":"","sources":["vat-ibc.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmBC"}

package/src/vat-ibc.js

@@ -1,14 +1,25 @@
-import { E, Far } from '@endo/far';
-import { makeIBCProtocolHandler } from './ibc.js';
-
-export function buildRootObject() {
-  function createInstance(callbacks) {
-    const ibcHandler = makeIBCProtocolHandler(E, (method, params) =>
-      E(callbacks).downcall(method, params),
-    );
+import { Far } from '@endo/far';
+import { makeDurableZone } from '@agoric/zone/durable.js';
+import { prepareVowTools } from '@agoric/vat-data/vow.js';
+import { prepareCallbacks, prepareIBCProtocol } from './ibc.js';
+
+export function buildRootObject(_vatPowers, _args, baggage) {
+  const zone = makeDurableZone(baggage);
+  const powers = prepareVowTools(zone.subZone('vow'));
+  const makeIBCProtocolHandler = prepareIBCProtocol(
+    zone.subZone('IBC'),
+    powers,
+  );
+
+  const makeCallbacks = prepareCallbacks(zone);
+
+  function createHandlers(callbacks) {
+    const ibcHandler = makeIBCProtocolHandler(callbacks);
     return harden(ibcHandler);
   }
+
   return Far('root', {
-    createInstance,
+    createHandlers,
+    makeCallbacks,
   });
 }