@agoric/orchestration 0.1.1-dev-0cfea88.0 → 0.1.1-dev-944adea.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/orchestration",
-  "version": "0.1.1-dev-0cfea88.0+0cfea88",
+  "version": "0.1.1-dev-944adea.0+944adea",
   "description": "Chain abstraction for Agoric's orchestration clients",
   "type": "module",
   "main": "index.js",
@@ -33,20 +33,20 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-0cfea88.0+0cfea88",
-    "@agoric/async-flow": "0.1.1-dev-0cfea88.0+0cfea88",
-    "@agoric/cosmic-proto": "0.4.1-dev-0cfea88.0+0cfea88",
-    "@agoric/ertp": "0.16.3-dev-0cfea88.0+0cfea88",
-    "@agoric/internal": "0.3.3-dev-0cfea88.0+0cfea88",
-    "@agoric/network": "0.1.1-dev-0cfea88.0+0cfea88",
-    "@agoric/notifier": "0.6.3-dev-0cfea88.0+0cfea88",
-    "@agoric/store": "0.9.3-dev-0cfea88.0+0cfea88",
-    "@agoric/time": "0.3.3-dev-0cfea88.0+0cfea88",
-    "@agoric/vat-data": "0.5.3-dev-0cfea88.0+0cfea88",
-    "@agoric/vats": "0.15.2-dev-0cfea88.0+0cfea88",
-    "@agoric/vow": "0.1.1-dev-0cfea88.0+0cfea88",
-    "@agoric/zoe": "0.26.3-dev-0cfea88.0+0cfea88",
-    "@agoric/zone": "0.2.3-dev-0cfea88.0+0cfea88",
+    "@agoric/assert": "0.6.1-dev-944adea.0+944adea",
+    "@agoric/async-flow": "0.1.1-dev-944adea.0+944adea",
+    "@agoric/cosmic-proto": "0.4.1-dev-944adea.0+944adea",
+    "@agoric/ertp": "0.16.3-dev-944adea.0+944adea",
+    "@agoric/internal": "0.3.3-dev-944adea.0+944adea",
+    "@agoric/network": "0.1.1-dev-944adea.0+944adea",
+    "@agoric/notifier": "0.6.3-dev-944adea.0+944adea",
+    "@agoric/store": "0.9.3-dev-944adea.0+944adea",
+    "@agoric/time": "0.3.3-dev-944adea.0+944adea",
+    "@agoric/vat-data": "0.5.3-dev-944adea.0+944adea",
+    "@agoric/vats": "0.15.2-dev-944adea.0+944adea",
+    "@agoric/vow": "0.1.1-dev-944adea.0+944adea",
+    "@agoric/zoe": "0.26.3-dev-944adea.0+944adea",
+    "@agoric/zone": "0.2.3-dev-944adea.0+944adea",
     "@endo/base64": "^1.0.5",
     "@endo/far": "^1.1.2",
     "@endo/marshal": "^1.5.0",
@@ -90,5 +90,5 @@
   "typeCoverage": {
     "atLeast": 97.1
   },
-  "gitHead": "0cfea88fb59d27dddb8b031a5b5539127b6a305e"
+  "gitHead": "944adea10660e68a65c10a2b32b6899919315e31"
 }

package/src/chain-info.d.ts

@@ -1,3 +1,4 @@
+export function registerChain(agoricNamesAdmin: ERef<import("@agoric/vats").NameHubKit["nameAdmin"]>, name: string, chainInfo: CosmosChainInfo, log?: (...messages: string[]) => void): Promise<void>;
 export function registerChainNamespace(agoricNamesAdmin: ERef<import("@agoric/vats").NameHubKit["nameAdmin"]>, log: (...messages: string[]) => void): Promise<void>;
 export type ChainInfo = CosmosChainInfo | EthChainInfo;
 export type KnownChains = typeof knownChains;

package/src/chain-info.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chain-info.d.ts","sourceRoot":"","sources":["chain-info.js"],"names":[],"mappings":"AAsEO,yDAHI,IAAI,CAAC,OAAO,cAAc,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,OACpD,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,KAAK,IAAI,iBAMzC;wBAnEa,eAAe,GAAG,YAAY;0BAyD9B,OAAO,WAAW;qCA3DiB,YAAY;kCAAZ,YAAY;AAA7D,iEAAiE;AAEjE,0DAA0D;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqDE"}
+{"version":3,"file":"chain-info.d.ts","sourceRoot":"","sources":["chain-info.js"],"names":[],"mappings":"AAyEO,gDALI,IAAI,CAAC,OAAO,cAAc,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,QACpD,MAAM,aACN,eAAe,QACf,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,KAAK,IAAI,iBAgCzC;AAMM,yDAHI,IAAI,CAAC,OAAO,cAAc,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,OACpD,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,KAAK,IAAI,iBAMzC;wBAzGa,eAAe,GAAG,YAAY;0BAyD9B,OAAO,WAAW;qCA3DiB,YAAY;kCAAZ,YAAY;AAA7D,iEAAiE;AAEjE,0DAA0D;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqDE"}

package/src/chain-info.js

@@ -1,7 +1,8 @@
-import { registerChain } from './exos/chain-hub.js';
-
-// Refresh with scripts/refresh-chain-info.ts
-import fetchedChainInfo from './fetched-chain-info.js';
+import { E } from '@endo/far';
+import { mustMatch } from '@endo/patterns';
+import { connectionKey } from './exos/chain-hub.js';
+import fetchedChainInfo from './fetched-chain-info.js'; // Refresh with scripts/refresh-chain-info.ts
+import { CosmosChainInfoShape } from './typeGuards.js';
 
 /** @import {CosmosChainInfo, EthChainInfo} from './types.js'; */
 
@@ -64,6 +65,44 @@ const knownChains = /** @satisfies {Record<string, ChainInfo>} */ (
 
 /** @typedef {typeof knownChains} KnownChains */
 
+/**
+ * @param {ERef<import('@agoric/vats').NameHubKit['nameAdmin']>} agoricNamesAdmin
+ * @param {string} name
+ * @param {CosmosChainInfo} chainInfo
+ * @param {(...messages: string[]) => void} log
+ */
+export const registerChain = async (
+  agoricNamesAdmin,
+  name,
+  chainInfo,
+  log = () => {},
+) => {
+  const { nameAdmin } = await E(agoricNamesAdmin).provideChild('chain');
+  const { nameAdmin: connAdmin } =
+    await E(agoricNamesAdmin).provideChild('chainConnection');
+
+  mustMatch(chainInfo, CosmosChainInfoShape);
+  const { connections = {}, ...vertex } = chainInfo;
+
+  const promises = [
+    E(nameAdmin)
+      .update(name, vertex)
+      .then(() => log(`registered agoricNames chain.${name}`)),
+  ];
+
+  // FIXME updates redundantly, twice per edge
+  for (const [counterChainId, connInfo] of Object.entries(connections)) {
+    const key = connectionKey(chainInfo.chainId, counterChainId);
+    promises.push(
+      E(connAdmin)
+        .update(key, connInfo)
+        .then(() => log(`registering agoricNames chainConnection.${key}`)),
+    );
+  }
+  // Bundle to pipeline IO
+  await Promise.all(promises);
+};
+
 /**
  * @param {ERef<import('@agoric/vats').NameHubKit['nameAdmin']>} agoricNamesAdmin
  * @param {(...messages: string[]) => void} log

package/src/examples/sendAnywhere.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sendAnywhere.contract.d.ts","sourceRoot":"","sources":["sendAnywhere.contract.js"],"names":[],"mappings":"AAYA;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AAEH,kEAKE;AASK,2BANI,GAAG,eACH,mBAAmB,GAAG;IAChC,UAAc,EAAE,UAAU,CAAC;CACxB,WACO,OAAO;;;;;QAsFZ;;;WAGG;4BAFQ,eAAe,kBACf,iBAAiB;;GAiBjC;kCA9HY;IACZ,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;CAC9B;6BAhBsB,kBAAkB;qCACS,eAAe;uCAAf,eAAe;gCAEvC,gCAAgC;4BAGpC,aAAa;0CAFC,eAAe;kCAFX,cAAc;6BAG/B,cAAc"}
+{"version":3,"file":"sendAnywhere.contract.d.ts","sourceRoot":"","sources":["sendAnywhere.contract.js"],"names":[],"mappings":"AAYA;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AAEH,kEAKE;AASK,2BANI,GAAG,eACH,mBAAmB,GAAG;IAChC,UAAc,EAAE,UAAU,CAAC;CACxB,WACO,OAAO;;;;;QAsFZ;;;WAGG;4BAFQ,eAAe,kBACf,iBAAiB;;GAmBjC;kCAhIY;IACZ,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;CAC9B;6BAhBsB,kBAAkB;qCACS,eAAe;uCAAf,eAAe;gCAEvC,gCAAgC;4BAGpC,aAAa;0CAFC,eAAe;kCAFX,cAAc;6BAG/B,cAAc"}

package/src/examples/sendAnywhere.contract.js

@@ -2,7 +2,7 @@ import { withdrawFromSeat } from '@agoric/zoe/src/contractSupport/zoeHelpers.js'
 import { InvitationShape } from '@agoric/zoe/src/typeGuards.js';
 import { E } from '@endo/far';
 import { M, mustMatch } from '@endo/patterns';
-
+import { V } from '@agoric/vow/vat.js';
 import { AmountShape } from '@agoric/ertp';
 import { CosmosChainInfoShape } from '../typeGuards.js';
 import { provideOrchestration } from '../utils/start-helper.js';
@@ -134,7 +134,9 @@ export const start = async (zcf, privateArgs, baggage) => {
        */
       async addChain(chainInfo, connectionInfo) {
         const chainKey = `${chainInfo.chainId}-${(nonce += 1n)}`;
-        const agoricChainInfo = await chainHub.getChainInfo('agoric');
+        // when() because chainHub methods return vows. If this were inside
+        // orchestrate() the membrane would wrap/unwrap automatically.
+        const agoricChainInfo = await V.when(chainHub.getChainInfo('agoric'));
         chainHub.registerChain(chainKey, chainInfo);
         chainHub.registerConnection(
           agoricChainInfo.chainId,

package/src/exos/chain-hub.d.ts

@@ -1,5 +1,6 @@
 /**
  * @import {NameHub} from '@agoric/vats';
+ * @import {Vow} from '@agoric/vow';
  * @import {CosmosChainInfo, IBCConnectionInfo} from '../cosmos-api.js';
  * @import {ChainInfo, KnownChains} from '../chain-info.js';
  * @import {Remote} from '@agoric/internal';
@@ -33,9 +34,9 @@ export function makeChainHub(agoricNames: Remote<NameHub>, zone?: Zone | undefin
     /**
      * @template {string} K
      * @param {K} chainName
-     * @returns {Promise<ActualChainInfo<K>>}
+     * @returns {Vow<ActualChainInfo<K>>}
      */
-    getChainInfo<K extends string>(chainName: K): Promise<ActualChainInfo<K>>;
+    getChainInfo<K extends string>(chainName: K): Vow<ActualChainInfo<K>>;
     /**
      * @param {string} chainId1
      * @param {string} chainId2
@@ -45,22 +46,31 @@ export function makeChainHub(agoricNames: Remote<NameHub>, zone?: Zone | undefin
     /**
      * @param {string | { chainId: string }} chain1
      * @param {string | { chainId: string }} chain2
-     * @returns {Promise<IBCConnectionInfo>}
+     * @returns {Vow<IBCConnectionInfo>}
      */
     getConnectionInfo(chain1: string | {
         chainId: string;
     }, chain2: string | {
         chainId: string;
-    }): Promise<IBCConnectionInfo>;
+    }): Vow<IBCConnectionInfo>;
+    /**
+     * @template {string} C1
+     * @template {string} C2
+     * @param {C1} chainName1
+     * @param {C2} chainName2
+     * @returns {Vow<
+     *   [ActualChainInfo<C1>, ActualChainInfo<C2>, IBCConnectionInfo]
+     * >}
+     */
+    getChainsAndConnection<C1 extends string, C2 extends string>(chainName1: C1, chainName2: C2): Vow<[ActualChainInfo<C1>, ActualChainInfo<C2>, IBCConnectionInfo]>;
 }>;
-export function registerChain(agoricNamesAdmin: ERef<import("@agoric/vats").NameHubKit["nameAdmin"]>, name: string, chainInfo: CosmosChainInfo, log?: (...messages: string[]) => void): Promise<void>;
-export function getChainsAndConnection<C1 extends string, C2 extends string>(chainHub: ChainHub, chainName1: C1, chainName2: C2): Promise<[ActualChainInfo<C1>, ActualChainInfo<C2>, IBCConnectionInfo]>;
 export type ActualChainInfo<K extends string> = K extends keyof KnownChains ? Omit<KnownChains[K], "connections"> : ChainInfo;
 export type ChainHub = ReturnType<typeof makeChainHub>;
 import type { NameHub } from '@agoric/vats';
 import type { Remote } from '@agoric/internal';
 import type { Zone } from '@agoric/zone';
 import type { CosmosChainInfo } from '../cosmos-api.js';
+import type { Vow } from '@agoric/vow';
 import type { IBCConnectionInfo } from '../cosmos-api.js';
 import type { KnownChains } from '../chain-info.js';
 import type { ChainInfo } from '../chain-info.js';

package/src/exos/chain-hub.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chain-hub.d.ts","sourceRoot":"","sources":["chain-hub.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AAEH;;;;;GAKG;AAEH,wCAAwC;AACxC,gCAAiC;AACjC,kCAAkC;AAClC,gDAAiD;AAqB1C,wCAHI,MAAM,YACN,MAAM,UAUhB;AAqCM,0CAHI,OAAO,OAAO,CAAC;IAgBtB;;;;;;;;;;;OAWG;wBAFQ,MAAM,aACN,eAAe;IAK1B;;;;OAIG;iBAHmB,CAAC,SAAV,MAAQ,aACV,CAAC,GACC,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;IAiBxC;;;;OAIG;iCAHQ,MAAM,YACN,MAAM,kBACN,iBAAiB;IAO5B;;;;OAIG;8BAHQ,MAAM,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,UAC5B,MAAM,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAC1B,OAAO,CAAC,iBAAiB,CAAC;GAqB1C;AASM,gDALI,IAAI,CAAC,OAAO,cAAc,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,QACpD,MAAM,aACN,eAAe,QACf,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,KAAK,IAAI,iBAgCzC;AAYM,uCATe,EAAE,SAAX,MAAQ,EACC,EAAE,SAAX,MAAQ,YACV,QAAQ,cACR,EAAE,cACF,EAAE,GACA,OAAO,CACnB,CAAK,eAAe,CAAC,EAAE,CAAC,EAAE,eAAe,CAAC,EAAE,CAAC,EAAE,iBAAiB,CAAC,CAC9D,CAcH;4BA5NqB,CAAC,SAAV,MAAQ,IACR,CAAC,SAAS,MAAM,WAAW,GACjC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,GACnC,SAAS;uBA2JF,UAAU,CAAC,OAAO,YAAY,CAAC;6BAtKnB,cAAc;4BAGf,kBAAkB;0BACpB,cAAc;qCAHgB,kBAAkB;uCAAlB,kBAAkB;iCAC9B,kBAAkB;+BAAlB,kBAAkB"}
+{"version":3,"file":"chain-hub.d.ts","sourceRoot":"","sources":["chain-hub.js"],"names":[],"mappings":"AASA;;;;;;;GAOG;AAEH;;;;;GAKG;AAEH,wCAAwC;AACxC,gCAAiC;AACjC,kCAAkC;AAClC,gDAAiD;AAqB1C,wCAHI,MAAM,YACN,MAAM,UAUhB;AAoCM,0CAHI,OAAO,OAAO,CAAC;IAgBtB;;;;;;;;;;;OAWG;wBAFQ,MAAM,aACN,eAAe;IAK1B;;;;OAIG;iBAHmB,CAAC,SAAV,MAAQ,aACV,CAAC,GACC,IAAI,eAAe,CAAC,CAAC,CAAC,CAAC;IAoBpC;;;;OAIG;iCAHQ,MAAM,YACN,MAAM,kBACN,iBAAiB;IAO5B;;;;OAIG;8BAHQ,MAAM,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,UAC5B,MAAM,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAC1B,IAAI,iBAAiB,CAAC;IAqBnC;;;;;;;;OAQG;2BAPmB,EAAE,SAAX,MAAQ,EACC,EAAE,SAAX,MAAQ,cACV,EAAE,cACF,EAAE,GACA,IACZ,CAAK,eAAe,CAAC,EAAE,CAAC,EAAE,eAAe,CAAC,EAAE,CAAC,EAAE,iBAAiB,CAAC,CAC9D;GAsBP;4BA5LqB,CAAC,SAAV,MAAQ,IACR,CAAC,SAAS,MAAM,WAAW,GACjC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,GACnC,SAAS;uBA0LF,UAAU,CAAC,OAAO,YAAY,CAAC;6BAtMnB,cAAc;4BAIf,kBAAkB;0BACpB,cAAc;qCAHgB,kBAAkB;yBADjD,aAAa;uCACkB,kBAAkB;iCAC9B,kBAAkB;+BAAlB,kBAAkB"}

package/src/exos/chain-hub.js

@@ -1,12 +1,15 @@
-import { E } from '@endo/far';
-import { M, mustMatch } from '@endo/patterns';
+import { VowShape } from '@agoric/vow';
+import { allVows, watch } from '@agoric/vow/vat.js';
 import { makeHeapZone } from '@agoric/zone';
+import { E } from '@endo/far';
+import { M } from '@endo/patterns';
 import { CosmosChainInfoShape, IBCConnectionInfoShape } from '../typeGuards.js';
 
 const { Fail } = assert;
 
 /**
  * @import {NameHub} from '@agoric/vats';
+ * @import {Vow} from '@agoric/vow';
  * @import {CosmosChainInfo, IBCConnectionInfo} from '../cosmos-api.js';
  * @import {ChainInfo, KnownChains} from '../chain-info.js';
  * @import {Remote} from '@agoric/internal';
@@ -67,15 +70,14 @@ const ChainIdArgShape = M.or(
 
 const ChainHubI = M.interface('ChainHub', {
   registerChain: M.call(M.string(), CosmosChainInfoShape).returns(),
-  getChainInfo: M.callWhen(M.string()).returns(CosmosChainInfoShape),
-  registerConnection: M.callWhen(
+  getChainInfo: M.call(M.string()).returns(VowShape),
+  registerConnection: M.call(
     M.string(),
     M.string(),
     IBCConnectionInfoShape,
   ).returns(),
-  getConnectionInfo: M.callWhen(ChainIdArgShape, ChainIdArgShape).returns(
-    IBCConnectionInfoShape,
-  ),
+  getConnectionInfo: M.call(ChainIdArgShape, ChainIdArgShape).returns(VowShape),
+  getChainsAndConnection: M.call(M.string(), M.string()).returns(VowShape),
 });
 
 /**
@@ -120,22 +122,25 @@ export const makeChainHub = (agoricNames, zone = makeHeapZone()) => {
     /**
      * @template {string} K
      * @param {K} chainName
-     * @returns {Promise<ActualChainInfo<K>>}
+     * @returns {Vow<ActualChainInfo<K>>}
      */
-    async getChainInfo(chainName) {
+    getChainInfo(chainName) {
       // Either from registerChain or memoized remote lookup()
       if (chainInfos.has(chainName)) {
-        // @ts-expect-error cast
-        return chainInfos.get(chainName);
+        return /** @type {Vow<ActualChainInfo<K>>} */ (
+          watch(chainInfos.get(chainName))
+        );
       }
 
-      const chainInfo = await E(agoricNames)
-        .lookup(CHAIN_KEY, chainName)
-        .catch(_cause => {
+      return watch(E(agoricNames).lookup(CHAIN_KEY, chainName), {
+        onFulfilled: chainInfo => {
+          chainInfos.init(chainName, chainInfo);
+          return chainInfo;
+        },
+        onRejected: _cause => {
           throw assert.error(`chain not found:${chainName}`);
-        });
-      chainInfos.init(chainName, chainInfo);
-      return chainInfo;
+        },
+      });
     },
     /**
      * @param {string} chainId1
@@ -150,88 +155,55 @@ export const makeChainHub = (agoricNames, zone = makeHeapZone()) => {
     /**
      * @param {string | { chainId: string }} chain1
      * @param {string | { chainId: string }} chain2
-     * @returns {Promise<IBCConnectionInfo>}
+     * @returns {Vow<IBCConnectionInfo>}
      */
-    async getConnectionInfo(chain1, chain2) {
+    getConnectionInfo(chain1, chain2) {
       const chainId1 = typeof chain1 === 'string' ? chain1 : chain1.chainId;
       const chainId2 = typeof chain2 === 'string' ? chain2 : chain2.chainId;
       const key = connectionKey(chainId1, chainId2);
       if (connectionInfos.has(key)) {
-        return connectionInfos.get(key);
+        return watch(connectionInfos.get(key));
       }
 
-      const connectionInfo = await E(agoricNames)
-        .lookup(CONNECTIONS_KEY, key)
-        .catch(_cause => {
+      return watch(E(agoricNames).lookup(CONNECTIONS_KEY, key), {
+        onFulfilled: connectionInfo => {
+          connectionInfos.init(key, connectionInfo);
+          return connectionInfo;
+        },
+        onRejected: _cause => {
           throw assert.error(`connection not found: ${chainId1}<->${chainId2}`);
-        });
-      connectionInfos.init(key, connectionInfo);
-      return connectionInfo;
+        },
+      });
+    },
+
+    /**
+     * @template {string} C1
+     * @template {string} C2
+     * @param {C1} chainName1
+     * @param {C2} chainName2
+     * @returns {Vow<
+     *   [ActualChainInfo<C1>, ActualChainInfo<C2>, IBCConnectionInfo]
+     * >}
+     */
+    getChainsAndConnection(chainName1, chainName2) {
+      return watch(
+        allVows([
+          chainHub.getChainInfo(chainName1),
+          chainHub.getChainInfo(chainName2),
+        ]),
+        {
+          onFulfilled: ([chain1, chain2]) => {
+            return watch(chainHub.getConnectionInfo(chain2, chain1), {
+              onFulfilled: connectionInfo => {
+                return [chain1, chain2, connectionInfo];
+              },
+            });
+          },
+        },
+      );
     },
   });
 
   return chainHub;
 };
 /** @typedef {ReturnType<typeof makeChainHub>} ChainHub */
-
-/**
- * @param {ERef<import('@agoric/vats').NameHubKit['nameAdmin']>} agoricNamesAdmin
- * @param {string} name
- * @param {CosmosChainInfo} chainInfo
- * @param {(...messages: string[]) => void} log
- */
-export const registerChain = async (
-  agoricNamesAdmin,
-  name,
-  chainInfo,
-  log = () => {},
-) => {
-  const { nameAdmin } = await E(agoricNamesAdmin).provideChild('chain');
-  const { nameAdmin: connAdmin } =
-    await E(agoricNamesAdmin).provideChild('chainConnection');
-
-  mustMatch(chainInfo, CosmosChainInfoShape);
-  const { connections = {}, ...vertex } = chainInfo;
-
-  const promises = [
-    E(nameAdmin)
-      .update(name, vertex)
-      .then(() => log(`registered agoricNames chain.${name}`)),
-  ];
-
-  // FIXME updates redundantly, twice per edge
-  for await (const [counterChainId, connInfo] of Object.entries(connections)) {
-    const key = connectionKey(chainInfo.chainId, counterChainId);
-    promises.push(
-      E(connAdmin)
-        .update(key, connInfo)
-        .then(() => log(`registering agoricNames chainConnection.${key}`)),
-    );
-  }
-  // Bundle to pipeline IO
-  await Promise.all(promises);
-};
-
-/**
- * @template {string} C1
- * @template {string} C2
- * @param {ChainHub} chainHub
- * @param {C1} chainName1
- * @param {C2} chainName2
- * @returns {Promise<
- *   [ActualChainInfo<C1>, ActualChainInfo<C2>, IBCConnectionInfo]
- * >}
- */
-export const getChainsAndConnection = async (
-  chainHub,
-  chainName1,
-  chainName2,
-) => {
-  const [chain1, chain2] = await Promise.all([
-    chainHub.getChainInfo(chainName1),
-    chainHub.getChainInfo(chainName2),
-  ]);
-  const connectionInfo = await chainHub.getConnectionInfo(chain2, chain1);
-
-  return [chain1, chain2, connectionInfo];
-};

package/src/exos/local-orchestration-account.d.ts

@@ -31,7 +31,7 @@ export function prepareLocalOrchestrationAccountKit(zone: Zone, makeRecorderKit:
          */
         onFulfilled(agoricChainInfo: ChainInfo, { destination }: {
             destination: ChainAddress;
-        }): Promise<IBCConnectionInfo>;
+        }): import("@agoric/vow").Vow<IBCConnectionInfo>;
     };
     getTimeoutTimestampWatcher: {
         /**

package/src/exos/local-orchestration-account.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"local-orchestration-account.d.ts","sourceRoot":"","sources":["local-orchestration-account.js"],"names":[],"mappings":"AAoEO,0DAPI,IAAI,mBACJ,eAAe,OACf,GAAG,gBACH,OAAO,YAAY,CAAC,4BACpB,QAAQ,YACR,QAAQ;aA6DJ,iBAAiB;aACjB,YAAY;iBACZ,OAAO,WAAW,CAAC;;;QAY1B;;;WAGG;mCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;QAYxB;;;WAGG;qCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;;;;QAgBxB;;;;WAIG;8BAHQ,CACV,UAAc,+CAA+C,CAAC,CAC3D;;;QAWJ;;;WAGG;iEADQ;YAAE,WAAW,EAAE,YAAY,CAAA;SAAE;;;QAUxC;;;WAGG;sCAFQ,MAAM,YACN;YAAE,IAAI,EAAE,qBAAqB,CAAA;SAAE;;;QAW1C;;;;;;;;;;WAUG;6DATQ,CACV;YAAM,eAAe,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,CAAA;SAAE,EAC7D,MAAU,CACP,iCACO;YACV,WAAe,EAAE,YAAY,CAAC;YAC9B,IAAQ,EAAE,qBAAqB,CAAC;YAChC,MAAU,EAAE,WAAW,CAAC;SACrB;;;;IA0BN;;;OAGG;;QAED;;WAEG;6BADQ,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE;;IAQvC;;;OAGG;;QAED;;WAEG;6BADQ,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE;;;QAUrC,sDAAsD;;;;;;;;;;QA4BtD;;;WAGG;mCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;QAoBxB;;;;WAIG;qCAHQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC,GACX,WAAW,IAAI,GAAG,eAAe,CAAC;QAmB/C;;;;WAIG;QACH,mDAAmD;;QAUnD,4CAA4C;;QAI5C,6CAA6C;;QAI7C,8BAA8B;sBAAhB,YAAY;;QAQ1B;;;;;;;;WAQG;yBAPQ,SAAS,eAET,YAAY,6CAIV,OAAO,CAAC,IAAI,CAAC;QA6B1B,yDAAyD;;;GAShE;;aAtYa,MAAM;;oBAIP;IACZ,QAAY,EAAE,YAAY,6BAA6B,CAAC,CAAC;IACzD,OAAW,EAAE,iBAAiB,CAAC;IAC/B,OAAW,EAAE,YAAY,CAAC;CACvB;+CA+XU,UAAU,CAAC,OAAO,mCAAmC,CAAC;2CACtD,UAAU,CAAC,gCAAgC,CAAC;0BArZnC,cAAc;qCADU,6CAA6C;kCAGhC,cAAc;4BADjD,kBAAkB;8BAEJ,aAAa;8BAEzB,gBAAgB;uCARP,gCAAgC;kCAC8D,uBAAuB;qCAI7F,cAAc;+BAE9C,sBAAsB;+BANgF,uBAAuB;uCAAvB,uBAAuB;2CAAvB,uBAAuB;iCAAvB,uBAAuB;gCAKlH,aAAa;+BAL8E,uBAAuB;iCAC1G,6CAA6C"}
+{"version":3,"file":"local-orchestration-account.d.ts","sourceRoot":"","sources":["local-orchestration-account.js"],"names":[],"mappings":"AAqEO,0DAPI,IAAI,mBACJ,eAAe,OACf,GAAG,gBACH,OAAO,YAAY,CAAC,4BACpB,QAAQ,YACR,QAAQ;aA6DJ,iBAAiB;aACjB,YAAY;iBACZ,OAAO,WAAW,CAAC;;;QAY1B;;;WAGG;mCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;QAYxB;;;WAGG;qCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;;;;QAgBxB;;;;WAIG;8BAHQ,CACV,UAAc,+CAA+C,CAAC,CAC3D;;;QAWJ;;;WAGG;iEADQ;YAAE,WAAW,EAAE,YAAY,CAAA;SAAE;;;QAUxC;;;WAGG;sCAFQ,MAAM,YACN;YAAE,IAAI,EAAE,qBAAqB,CAAA;SAAE;;;QAW1C;;;;;;;;;;WAUG;6DATQ,CACV;YAAM,eAAe,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,CAAA;SAAE,EAC7D,MAAU,CACP,iCACO;YACV,WAAe,EAAE,YAAY,CAAC;YAC9B,IAAQ,EAAE,qBAAqB,CAAC;YAChC,MAAU,EAAE,WAAW,CAAC;SACrB;;;;IA0BN;;;OAGG;;QAED;;WAEG;6BADQ,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE;;IAQvC;;;OAGG;;QAED;;WAEG;6BADQ,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE;;;QAUrC,sDAAsD;;;;;;;;;;QA4BtD;;;WAGG;mCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;QAoBxB;;;;WAIG;qCAHQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC,GACX,WAAW,IAAI,GAAG,eAAe,CAAC;QAmB/C;;;;WAIG;QACH,mDAAmD;;QAUnD,4CAA4C;;QAI5C,6CAA6C;;QAI7C,8BAA8B;sBAAhB,YAAY;;QAQ1B;;;;;;;;WAQG;yBAPQ,SAAS,eAET,YAAY,6CAIV,OAAO,CAAC,IAAI,CAAC;QA6B1B,yDAAyD;;;GAShE;;aAtYa,MAAM;;oBAIP;IACZ,QAAY,EAAE,YAAY,6BAA6B,CAAC,CAAC;IACzD,OAAW,EAAE,iBAAiB,CAAC;IAC/B,OAAW,EAAE,YAAY,CAAC;CACvB;+CA+XU,UAAU,CAAC,OAAO,mCAAmC,CAAC;2CACtD,UAAU,CAAC,gCAAgC,CAAC;0BArZnC,cAAc;qCADU,6CAA6C;kCAGhC,cAAc;4BADjD,kBAAkB;8BAEJ,aAAa;8BAEzB,gBAAgB;uCARP,gCAAgC;kCAC8D,uBAAuB;qCAI7F,cAAc;+BAE9C,sBAAsB;+BANgF,uBAAuB;uCAAvB,uBAAuB;2CAAvB,uBAAuB;iCAAvB,uBAAuB;gCAKlH,aAAa;+BAL8E,uBAAuB;iCAC1G,6CAA6C"}

package/src/exos/local-orchestration-account.js

@@ -3,6 +3,7 @@ import { typedJson } from '@agoric/cosmic-proto/vatsafe';
 import { AmountShape, PaymentShape } from '@agoric/ertp';
 import { makeTracer } from '@agoric/internal';
 import { M } from '@agoric/vat-data';
+import { VowShape } from '@agoric/vow';
 import { V } from '@agoric/vow/vat.js';
 import { TopicsRecordShape } from '@agoric/zoe/src/contractSupport/index.js';
 import { InvitationShape } from '@agoric/zoe/src/typeGuards.js';
@@ -89,7 +90,7 @@ export const prepareLocalOrchestrationAccountKit = (
       getChainInfoWatcher: M.interface('getChainInfoWatcher', {
         onFulfilled: M.call(M.record()) // agoric chain info
           .optional({ destination: ChainAddressShape }) // empty context
-          .returns(M.promise()), // transfer channel
+          .returns(VowShape), // transfer channel
       }),
       getTimeoutTimestampWatcher: M.interface('getTimeoutTimestampWatcher', {
         onFulfilled: M.call(M.bigint())

package/src/exos/orchestrator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["orchestrator.js"],"names":[],"mappings":"AAkCA,0BAA0B;AAC1B;;;;;GAKG;AAkBI,6CAfI,IAAI,qGACJ;IACV,cAAkB,EAAE,cAAc,CAAC;IACnC,QAAY,EAAE,QAAQ,CAAC;IACvB,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,eAAmB,EAAE,eAAe,CAAC;IACrC,oBAAwB,EAAE,oBAAoB,CAAC;IAC/C,qBAAyB,EAAE,qBAAqB,CAAC;IACjD,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,QAAY,EAAE,QAAQ,CAAC;IACvB,GAAO,EAAE,GAAG,CAAC;CACV;IAmCE,2DAA2D;;QAEzD,yCAAyC;;;;;;;;;;;;;IAK3C;;;OAGG;;QAED;;;;;WAKG;;;;;;;;;;;;;;QAMH,uCAAuC;;;;;;;;;;;;;GAwB5C;0BA3HoB,mBAAmB;oCAET,oBAAoB;8BAD1B,gBAAgB;gCAId,gCAAgC;4BAEpC,kBAAkB;qCADI,6CAA6C;0CAKrD,yBAAyB;2CACxB,0BAA0B;0CAH3B,eAAe;kCALvB,cAAc;8BADb,aAAa;+BAU8D,aAAa;uCAAb,aAAa;0CAAb,aAAa;2BAAb,aAAa"}
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["orchestrator.js"],"names":[],"mappings":"AAiCA,0BAA0B;AAC1B;;;;;GAKG;AAkBI,6CAfI,IAAI,qGACJ;IACV,cAAkB,EAAE,cAAc,CAAC;IACnC,QAAY,EAAE,QAAQ,CAAC;IACvB,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,eAAmB,EAAE,eAAe,CAAC;IACrC,oBAAwB,EAAE,oBAAoB,CAAC;IAC/C,qBAAyB,EAAE,qBAAqB,CAAC;IACjD,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,QAAY,EAAE,QAAQ,CAAC;IACvB,GAAO,EAAE,GAAG,CAAC;CACV;IAmCE,2DAA2D;;QAEzD,yCAAyC;;;;;;;;;;;;;IAK3C;;;OAGG;;QAED;;;;;WAKG;;;;;;;;;;;;;;QAMH,uCAAuC;;;;;;;;;;;;;GA0B5C;0BA7HoB,mBAAmB;oCAET,oBAAoB;8BAD1B,gBAAgB;gCAId,gCAAgC;4BAEpC,kBAAkB;qCADI,6CAA6C;0CAKrD,yBAAyB;2CACxB,0BAA0B;0CAH3B,eAAe;kCALvB,cAAc;8BADb,aAAa;+BAU8D,aAAa;uCAAb,aAAa;0CAAb,aAAa;2BAAb,aAAa"}

package/src/exos/orchestrator.js

@@ -4,13 +4,12 @@ import { makeTracer } from '@agoric/internal';
 import { E } from '@endo/far';
 import { M } from '@endo/patterns';
 import {
-  ChainInfoShape,
-  LocalChainAccountShape,
-  DenomShape,
   BrandInfoShape,
+  ChainInfoShape,
   DenomAmountShape,
+  DenomShape,
+  LocalChainAccountShape,
 } from '../typeGuards.js';
-import { getChainsAndConnection } from './chain-hub.js';
 
 /**
  * @import {Zone} from '@agoric/base-zone';
@@ -78,7 +77,7 @@ export const prepareOrchestratorKit = (
       makeRemoteChainFacadeWatcher: M.interface(
         'makeRemoteChainFacadeWatcher',
         {
-          onFulfilled: M.call(M.arrayOf(M.record()))
+          onFulfilled: M.call(M.any())
             .optional(M.arrayOf(M.undefined()))
             .returns(M.any()), // FIXME narrow
         },
@@ -115,6 +114,7 @@ export const prepareOrchestratorKit = (
         /** @type {Orchestrator['getChain']} */
         getChain(name) {
           if (name === 'agoric') {
+            // XXX when() until membrane
             return when(
               watch(
                 chainHub.getChainInfo('agoric'),
@@ -122,9 +122,10 @@ export const prepareOrchestratorKit = (
               ),
             );
           }
+          // XXX when() until membrane
           return when(
             watch(
-              getChainsAndConnection(chainHub, 'agoric', name),
+              chainHub.getChainsAndConnection('agoric', name),
               this.facets.makeRemoteChainFacadeWatcher,
             ),
           );

package/src/facade.d.ts

@@ -15,15 +15,20 @@ export function makeOrchestrationFacade({ zone, timerService, zcf, storageNode,
     asyncFlowTools: AsyncFlowTools;
 }): {
     /**
+     * @template Return
      * @template Context
      * @template {any[]} Args
      * @param {string} durableName - the orchestration flow identity in the zone
      *   (to resume across upgrades)
      * @param {Context} ctx - values to pass through the async flow membrane
-     * @param {(orc: Orchestrator, ctx2: Context, ...args: Args) => object} fn
-     * @returns {(...args: Args) => Promise<unknown>}
+     * @param {(
+     *   orc: Orchestrator,
+     *   ctx2: Context,
+     *   ...args: Args
+     * ) => Promise<Return>} fn
+     * @returns {(...args: Args) => Promise<Return>}
      */
-    orchestrate<Context, Args extends any[]>(durableName: string, ctx: Context, fn: (orc: Orchestrator, ctx2: Context, ...args: Args) => object): (...args: Args) => Promise<unknown>;
+    orchestrate<Return, Context, Args extends any[]>(durableName: string, ctx: Context, fn: (orc: Orchestrator, ctx2: Context, ...args: Args) => Promise<Return>): (...args: Args) => Promise<Return>;
 };
 export type OrchestrationFacade = ReturnType<typeof makeOrchestrationFacade>;
 import type { Zone } from '@agoric/zone';

package/src/facade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"facade.d.ts","sourceRoot":"","sources":["facade.js"],"names":[],"mappings":"AAwCO,yPAjBI;IACV,IAAQ,EAAE,IAAI,CAAC;IACf,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,GAAO,EAAE,GAAG,CAAC;IACb,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,QAAY,EAAE,OAAO,qBAAqB,EAAE,QAAQ,CAAC;IACrD,gCAAoC,EAAE,gCAAgC,CAAC;IACvE,eAAmB,EAAE,eAAe,CAAC;IACrC,8BAAkC,EAAE,GAAG,CAAC;IACxC,oBAAwB,EAAE,oBAAoB,CAAC;IAC/C,qBAAyB,EAAE,qBAAqB,CAAC;IACjD,QAAY,EAAE,QAAQ,CAAC;IACvB,cAAkB,EAAE,cAAc,CAAC;CAChC;IA+CA;;;;;;;;OAQG;gBAPU,OAAO,EACC,IAAI,SAAX,GAAG,EAAG,eACT,MAAM,OAEN,OAAO,MACP,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,IAAI,KAAK,MAAM,GACzD,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,OAAO,CAAC;EAQnD;kCAEa,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BA9FjC,cAAc;kCAEN,cAAc;4BAIpB,kBAAkB;0CACJ,cAAc;gCAHxB,gCAAgC;sDAOV,uCAAuC;qCAN3C,6CAA6C;0CAIrD,8BAA8B;2CAC7B,+BAA+B;8BATvC,aAAa;oCAFZ,oBAAoB;kCASsD,YAAY"}
+{"version":3,"file":"facade.d.ts","sourceRoot":"","sources":["facade.js"],"names":[],"mappings":"AAwCO,yPAjBI;IACV,IAAQ,EAAE,IAAI,CAAC;IACf,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,GAAO,EAAE,GAAG,CAAC;IACb,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,QAAY,EAAE,OAAO,qBAAqB,EAAE,QAAQ,CAAC;IACrD,gCAAoC,EAAE,gCAAgC,CAAC;IACvE,eAAmB,EAAE,eAAe,CAAC;IACrC,8BAAkC,EAAE,GAAG,CAAC;IACxC,oBAAwB,EAAE,oBAAoB,CAAC;IAC/C,qBAAyB,EAAE,qBAAqB,CAAC;IACjD,QAAY,EAAE,QAAQ,CAAC;IACvB,cAAkB,EAAE,cAAc,CAAC;CAChC;IA+CA;;;;;;;;;;;;;OAaG;gBAZU,MAAM,EACN,OAAO,EACC,IAAI,SAAX,GAAG,EAAG,eACT,MAAM,OAEN,OAAO,MACP,CACV,GAAO,EAAE,YAAY,EACrB,IAAQ,EAAE,OAAO,EACjB,GAAO,IAAI,EAAE,IAAI,KACV,OAAO,CAAC,MAAM,CAAC,GACV,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC;EAQlD;kCAEa,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BAnGjC,cAAc;kCAEN,cAAc;4BAIpB,kBAAkB;0CACJ,cAAc;gCAHxB,gCAAgC;sDAOV,uCAAuC;qCAN3C,6CAA6C;0CAIrD,8BAA8B;2CAC7B,+BAA+B;8BATvC,aAAa;oCAFZ,oBAAoB;kCASsD,YAAY"}

package/src/facade.js

@@ -84,18 +84,23 @@ export const makeOrchestrationFacade = ({
 
   return {
     /**
+     * @template Return
      * @template Context
      * @template {any[]} Args
      * @param {string} durableName - the orchestration flow identity in the zone
      *   (to resume across upgrades)
      * @param {Context} ctx - values to pass through the async flow membrane
-     * @param {(orc: Orchestrator, ctx2: Context, ...args: Args) => object} fn
-     * @returns {(...args: Args) => Promise<unknown>}
+     * @param {(
+     *   orc: Orchestrator,
+     *   ctx2: Context,
+     *   ...args: Args
+     * ) => Promise<Return>} fn
+     * @returns {(...args: Args) => Promise<Return>}
      */
     orchestrate(durableName, ctx, fn) {
       const orc = makeOrchestrator();
 
-      return async (...args) => fn(orc, ctx, ...args);
+      return async (...args) => vowTools.when(fn(orc, ctx, ...args));
     },
   };
 };

package/src/proposals/start-stakeAtom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"start-stakeAtom.d.ts","sourceRoot":"","sources":["start-stakeAtom.js"],"names":[],"mappings":"AAuBO,yOAVI,eAAe,GAAG;IAC5B,YAAgB,EAAE;QAClB,OAAa,EAAE;YACf,QAAgB,EAAE,YAAY,CAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA0D,CACjD,CAAC;SACH,CAAC;KACH,CAAC;CACH,iBAsDH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BN;mCAnG4C,+BAA+B"}
+{"version":3,"file":"start-stakeAtom.d.ts","sourceRoot":"","sources":["start-stakeAtom.js"],"names":[],"mappings":"AAwBO,yOAVI,eAAe,GAAG;IAC5B,YAAgB,EAAE;QAClB,OAAa,EAAE;YACf,QAAgB,EAAE,YAAY,CAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA0D,CACjD,CAAC;SACH,CAAC;KACH,CAAC;CACH,iBAoDH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BN;mCAjG4C,+BAA+B"}

package/src/proposals/start-stakeAtom.js

@@ -1,7 +1,8 @@
 import { makeTracer } from '@agoric/internal';
 import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
 import { E } from '@endo/far';
-import { getChainsAndConnection, makeChainHub } from '../exos/chain-hub.js';
+import { V } from '@agoric/vow/vat.js';
+import { makeChainHub } from '../exos/chain-hub.js';
 
 /**
  * @import {IBCConnectionID} from '@agoric/vats';
@@ -46,10 +47,8 @@ export const startStakeAtom = async ({
 
   const chainHub = makeChainHub(await agoricNames);
 
-  const [_, cosmoshub, connectionInfo] = await getChainsAndConnection(
-    chainHub,
-    'agoric',
-    'cosmoshub',
+  const [_, cosmoshub, connectionInfo] = await V.when(
+    chainHub.getChainsAndConnection('agoric', 'cosmoshub'),
   );
 
   /** @type {StartUpgradableOpts<StakeIcaSF>} */

package/src/proposals/start-stakeOsmo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"start-stakeOsmo.d.ts","sourceRoot":"","sources":["start-stakeOsmo.js"],"names":[],"mappings":"AAuBO,yOAVI,eAAe,GAAG;IAC5B,YAAgB,EAAE;QAClB,OAAa,EAAE;YACf,QAAgB,EAAE,YAAY,CAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA0D,CACjD,CAAC;SACH,CAAC;KACH,CAAC;CACH,iBAuDH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BN"}
+{"version":3,"file":"start-stakeOsmo.d.ts","sourceRoot":"","sources":["start-stakeOsmo.js"],"names":[],"mappings":"AAwBO,yOAVI,eAAe,GAAG;IAC5B,YAAgB,EAAE;QAClB,OAAa,EAAE;YACf,QAAgB,EAAE,YAAY,CAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA0D,CACjD,CAAC;SACH,CAAC;KACH,CAAC;CACH,iBAqDH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BN"}

package/src/proposals/start-stakeOsmo.js

@@ -1,7 +1,8 @@
 import { makeTracer } from '@agoric/internal';
 import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
+import { V } from '@agoric/vow/vat.js';
 import { E } from '@endo/far';
-import { getChainsAndConnection, makeChainHub } from '../exos/chain-hub.js';
+import { makeChainHub } from '../exos/chain-hub.js';
 
 /**
  * @import {IBCConnectionID} from '@agoric/vats';
@@ -47,10 +48,8 @@ export const startStakeOsmo = async ({
 
   const chainHub = makeChainHub(await agoricNames);
 
-  const [_, osmosis, connectionInfo] = await getChainsAndConnection(
-    chainHub,
-    'agoric',
-    'osmosis',
+  const [_, osmosis, connectionInfo] = await V.when(
+    chainHub.getChainsAndConnection('agoric', 'osmosis'),
   );
 
   /** @type {StartUpgradableOpts<StakeIcaSF>} */

package/src/utils/start-helper.d.ts

@@ -1,16 +1,17 @@
 export function provideOrchestration(zcf: ZCF, baggage: Baggage, remotePowers: OrchestrationPowers, marshaller: Marshaller): {
     chainHub: import("@endo/exo").Guarded<{
         registerChain(name: string, chainInfo: import("../cosmos-api.js").CosmosChainInfo): void;
-        getChainInfo<K extends string>(chainName: K): Promise<ActualChainInfo<K>>;
+        getChainInfo<K extends string>(chainName: K): import("@agoric/vow").Vow<ActualChainInfo<K>>;
         registerConnection(chainId1: string, chainId2: string, connectionInfo: import("../cosmos-api.js").IBCConnectionInfo): void;
         getConnectionInfo(chain1: string | {
             chainId: string;
         }, chain2: string | {
             chainId: string;
-        }): Promise<import("../cosmos-api.js").IBCConnectionInfo>;
+        }): import("@agoric/vow").Vow<import("../cosmos-api.js").IBCConnectionInfo>;
+        getChainsAndConnection<C1 extends string, C2 extends string>(chainName1: C1, chainName2: C2): import("@agoric/vow").Vow<[ActualChainInfo<C1>, ActualChainInfo<C2>, import("../cosmos-api.js").IBCConnectionInfo]>;
     }>;
     zone: import("@agoric/base-zone").Zone;
-    orchestrate<Context, Args extends any[]>(durableName: string, ctx: Context, fn: (orc: import("../orchestration-api.js").Orchestrator, ctx2: Context, ...args: Args) => object): (...args: Args) => Promise<unknown>;
+    orchestrate<Return, Context, Args extends any[]>(durableName: string, ctx: Context, fn: (orc: import("../orchestration-api.js").Orchestrator, ctx2: Context, ...args: Args) => Promise<Return>): (...args: Args) => Promise<Return>;
 };
 export type OrchestrationPowers = {
     localchain: Remote<LocalChain>;

package/src/utils/start-helper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"start-helper.d.ts","sourceRoot":"","sources":["start-helper.js"],"names":[],"mappings":"AAwCO,0CALI,GAAG,WACH,OAAO,gBACP,mBAAmB,cACnB,UAAU;;;;;;;;;;;;yJAyDH,GACjB,yBACQ,GAAG;EAOX;kCAlFY;IACZ,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;CAC9B;6BAbsB,kBAAkB;gCAFf,gCAAgC;4BAIpC,aAAa;0CACC,eAAe;kCAJX,cAAc;6BAE/B,cAAc"}
+{"version":3,"file":"start-helper.d.ts","sourceRoot":"","sources":["start-helper.js"],"names":[],"mappings":"AAwCO,0CALI,GAAG,WACH,OAAO,gBACP,mBAAmB,cACnB,UAAU;;;;;;;;;;;;;iKA2DjB,GAAa,kCAGZ,GAAG;EAIP;kCAlFY;IACZ,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;CAC9B;6BAbsB,kBAAkB;gCAFf,gCAAgC;4BAIpC,aAAa;0CACC,eAAe;kCAJX,cAAc;6BAE/B,cAAc"}