@agoric/orchestration 0.1.1-dev-c5c52ec.0 → 0.1.1-dev-01a1123.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/orchestration",
-  "version": "0.1.1-dev-c5c52ec.0+c5c52ec",
+  "version": "0.1.1-dev-01a1123.0+01a1123",
   "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-c5c52ec.0+c5c52ec",
-    "@agoric/async-flow": "0.1.1-dev-c5c52ec.0+c5c52ec",
-    "@agoric/cosmic-proto": "0.4.1-dev-c5c52ec.0+c5c52ec",
-    "@agoric/ertp": "0.16.3-dev-c5c52ec.0+c5c52ec",
-    "@agoric/internal": "0.3.3-dev-c5c52ec.0+c5c52ec",
-    "@agoric/network": "0.1.1-dev-c5c52ec.0+c5c52ec",
-    "@agoric/notifier": "0.6.3-dev-c5c52ec.0+c5c52ec",
-    "@agoric/store": "0.9.3-dev-c5c52ec.0+c5c52ec",
-    "@agoric/time": "0.3.3-dev-c5c52ec.0+c5c52ec",
-    "@agoric/vat-data": "0.5.3-dev-c5c52ec.0+c5c52ec",
-    "@agoric/vats": "0.15.2-dev-c5c52ec.0+c5c52ec",
-    "@agoric/vow": "0.1.1-dev-c5c52ec.0+c5c52ec",
-    "@agoric/zoe": "0.26.3-dev-c5c52ec.0+c5c52ec",
-    "@agoric/zone": "0.2.3-dev-c5c52ec.0+c5c52ec",
+    "@agoric/assert": "0.6.1-dev-01a1123.0+01a1123",
+    "@agoric/async-flow": "0.1.1-dev-01a1123.0+01a1123",
+    "@agoric/cosmic-proto": "0.4.1-dev-01a1123.0+01a1123",
+    "@agoric/ertp": "0.16.3-dev-01a1123.0+01a1123",
+    "@agoric/internal": "0.3.3-dev-01a1123.0+01a1123",
+    "@agoric/network": "0.1.1-dev-01a1123.0+01a1123",
+    "@agoric/notifier": "0.6.3-dev-01a1123.0+01a1123",
+    "@agoric/store": "0.9.3-dev-01a1123.0+01a1123",
+    "@agoric/time": "0.3.3-dev-01a1123.0+01a1123",
+    "@agoric/vat-data": "0.5.3-dev-01a1123.0+01a1123",
+    "@agoric/vats": "0.15.2-dev-01a1123.0+01a1123",
+    "@agoric/vow": "0.1.1-dev-01a1123.0+01a1123",
+    "@agoric/zoe": "0.26.3-dev-01a1123.0+01a1123",
+    "@agoric/zone": "0.2.3-dev-01a1123.0+01a1123",
     "@endo/base64": "^1.0.5",
     "@endo/far": "^1.1.2",
     "@endo/marshal": "^1.5.0",
@@ -90,5 +90,5 @@
   "typeCoverage": {
     "atLeast": 97.1
   },
-  "gitHead": "c5c52ec69b4befd3cf5c7eedc817904978599ec6"
+  "gitHead": "01a1123a526b11e11fa1ef80e0c532a616cd29b9"
 }

package/src/chain-info.d.ts

@@ -1,5 +1,5 @@
-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 function registerChain(agoricNamesAdmin: ERef<import("@agoric/vats").NameHubKit["nameAdmin"]>, name: string, chainInfo: CosmosChainInfo, log?: ((...messages: string[]) => void) | undefined): Promise<void>;
+export function registerChainNamespace(agoricNamesAdmin: ERef<import("@agoric/vats").NameHubKit["nameAdmin"]>, log?: ((...messages: string[]) => void) | undefined): Promise<void>;
 export type ChainInfo = CosmosChainInfo | EthChainInfo;
 export type KnownChains = typeof knownChains;
 import type { CosmosChainInfo } from './types.js';

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

@@ -1 +1 @@
-{"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"}
+{"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,uBACD,MAAM,EAAE,KAAK,IAAI,8BAgCzC;AAMM,yDAHI,IAAI,CAAC,OAAO,cAAc,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,uBACtC,MAAM,EAAE,KAAK,IAAI,8BAMzC;wBAzGa,eAAe,GAAG,YAAY;0BAyD9B,OAAO,WAAW;qCA3DiB,YAAY;kCAAZ,YAAY;AAA7D,iEAAiE;AAEjE,0DAA0D;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqDE"}

package/src/chain-info.js

@@ -69,7 +69,7 @@ const knownChains = /** @satisfies {Record<string, ChainInfo>} */ (
  * @param {ERef<import('@agoric/vats').NameHubKit['nameAdmin']>} agoricNamesAdmin
  * @param {string} name
  * @param {CosmosChainInfo} chainInfo
- * @param {(...messages: string[]) => void} log
+ * @param {(...messages: string[]) => void} [log]
  */
 export const registerChain = async (
   agoricNamesAdmin,
@@ -105,7 +105,7 @@ export const registerChain = async (
 
 /**
  * @param {ERef<import('@agoric/vats').NameHubKit['nameAdmin']>} agoricNamesAdmin
- * @param {(...messages: string[]) => void} log
+ * @param {(...messages: string[]) => void} [log]
  */
 export const registerChainNamespace = async (agoricNamesAdmin, log) => {
   for await (const [name, info] of Object.entries(knownChains)) {

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;;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"}
+{"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;;;;;QA2FZ;;;WAGG;4BAFQ,eAAe,kBACf,iBAAiB;;GAmBjC;kCArIY;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

@@ -83,11 +83,16 @@ export const start = async (zcf, privateArgs, baggage) => {
       // FIXME ok to use a heap var crossing the membrane scope this way?
       if (!contractAccount) {
         const agoricChain = await orch.getChain('agoric');
-        contractAccount = await agoricChain.makeAccount();
+        // XXX when() until membrane
+        contractAccount = await V.when(agoricChain.makeAccount());
+        console.log('contractAccount', contractAccount);
       }
 
-      const info = await chain.getChainInfo();
+      // XXX when() until membrane
+      const info = await V.when(chain.getChainInfo());
+      console.log('info', info);
       const { chainId } = info;
+      assert(typeof chainId === 'string', 'bad chainId');
       const { [kw]: pmtP } = await withdrawFromSeat(zcf, seat, give);
       await E.when(pmtP, pmt => contractAccount.deposit(pmt));
       await contractAccount.transfer(

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

@@ -1 +1 @@
-{"version":3,"file":"swapExample.contract.d.ts","sourceRoot":"","sources":["swapExample.contract.js"],"names":[],"mappings":"AASA;;;;;;;;GAQG;AAEH,yCAAyC;AACzC,mBADW,YAAY,CAAC,OAAO,KAAK,CAAC,CAWnC;AASK,0CAHI,KAAK;;;EAIsC;AAc/C,2BAXI,GAAG,eACH;IACV,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;IACjC,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,UAAc,EAAE,UAAU,CAAC;CACxB,WACO,OAAO;;;oBA+BD,MAAM,CAAC,KAAK,CAAC;uBAAa,sBAAsB;;;;oBAAhD,MAAM,CAAC,KAAK,CAAC;uBAAa,sBAAsB;;;GAoEhE;6BAvIyB,cAAc;4BAHf,kBAAkB;gCADd,gCAAgC;0CAEtB,eAAe;kCAHvB,cAAc;6BAInB,kBAAkB;4CALuB,aAAa"}
+{"version":3,"file":"swapExample.contract.d.ts","sourceRoot":"","sources":["swapExample.contract.js"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AAEH,yCAAyC;AACzC,mBADW,YAAY,CAAC,OAAO,KAAK,CAAC,CAWnC;AASK,0CAHI,KAAK;;;EAIsC;AAc/C,2BAXI,GAAG,eACH;IACV,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;IACjC,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,UAAc,EAAE,UAAU,CAAC;CACxB,WACO,OAAO;;;oBA+BD,MAAM,CAAC,KAAK,CAAC;uBAAa,sBAAsB;;;;oBAAhD,MAAM,CAAC,KAAK,CAAC;uBAAa,sBAAsB;;;GAsEhE;6BAzIyB,cAAc;4BAHf,kBAAkB;gCADd,gCAAgC;0CAEtB,eAAe;kCAHvB,cAAc;6BAInB,kBAAkB;4CALuB,aAAa"}

package/src/examples/swapExample.contract.js

@@ -4,6 +4,7 @@ import { withdrawFromSeat } from '@agoric/zoe/src/contractSupport/zoeHelpers.js'
 import { Far } from '@endo/far';
 import { deeplyFulfilled } from '@endo/marshal';
 import { M, objectMap } from '@endo/patterns';
+import { when } from '@agoric/vow/vat.js';
 import { orcUtils } from '../utils/orc.js';
 import { provideOrchestration } from '../utils/start-helper.js';
 
@@ -95,8 +96,10 @@ export const start = async (zcf, privateArgs, baggage) => {
       const agoric = await orch.getChain('agoric');
 
       const [omniAccount, localAccount] = await Promise.all([
-        omni.makeAccount(),
-        agoric.makeAccount(),
+        // XXX when() until membrane
+        when(omni.makeAccount()),
+        // XXX when() until membrane
+        when(agoric.makeAccount()),
       ]);
 
       const omniAddress = omniAccount.getAddress();

package/src/exos/local-chain-facade.d.ts

@@ -1,9 +1,10 @@
-export function prepareLocalChainFacade(zone: Zone, { makeLocalOrchestrationAccountKit, localchain, storageNode }: {
+export function prepareLocalChainFacade(zone: Zone, { makeLocalOrchestrationAccountKit, localchain, storageNode, vowTools: { allVows }, }: {
     makeLocalOrchestrationAccountKit: MakeLocalOrchestrationAccountKit;
     orchestration: Remote<OrchestrationService>;
     storageNode: Remote<StorageNode>;
     timer: Remote<TimerService>;
     localchain: Remote<LocalChain>;
+    vowTools: VowTools;
 }): (localChainInfo: Readonly<{
     chainId: string;
     connections?: Record<string, IBCConnectionInfo>;
@@ -12,7 +13,7 @@ export function prepareLocalChainFacade(zone: Zone, { makeLocalOrchestrationAcco
         denom: string;
     }>>;
 }>) => import("@endo/exo").Guarded<{
-    getChainInfo(): Promise<Readonly<{
+    getChainInfo(): Vow<Readonly<{
         chainId: string;
         connections?: Record<string, IBCConnectionInfo>;
         icqEnabled?: boolean;
@@ -20,8 +21,8 @@ export function prepareLocalChainFacade(zone: Zone, { makeLocalOrchestrationAcco
             denom: string;
         }>>;
     }>>;
-    /** @returns {Promise<OrchestrationAccount<ChainInfo>>} */
-    makeAccount(): Promise<OrchestrationAccount<ChainInfo>>;
+    /** @returns {Vow<OrchestrationAccount<ChainInfo>>} */
+    makeAccount(): Vow<OrchestrationAccount<ChainInfo>>;
 }>;
 export type MakeLocalChainFacade = ReturnType<typeof prepareLocalChainFacade>;
 import type { Zone } from '@agoric/base-zone';
@@ -30,7 +31,9 @@ import type { OrchestrationService } from '../service.js';
 import type { Remote } from '@agoric/internal';
 import type { TimerService } from '@agoric/time';
 import type { LocalChain } from '@agoric/vats/src/localchain.js';
+import type { VowTools } from '@agoric/vow';
 import type { IBCConnectionInfo } from '../types.js';
+import type { Vow } from '@agoric/vow';
 import type { ChainInfo } from '../types.js';
 import type { OrchestrationAccount } from '../types.js';
 //# sourceMappingURL=local-chain-facade.d.ts.map

package/src/exos/local-chain-facade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"local-chain-facade.d.ts","sourceRoot":"","sources":["local-chain-facade.js"],"names":[],"mappings":"AAyBO,8CATI,IAAI,iEACJ;IACV,gCAAoC,EAAE,gCAAgC,CAAC;IACvE,aAAiB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IAChD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,KAAS,EAAE,OAAO,YAAY,CAAC,CAAC;IAChC,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;CAChC;;;;;;;;;;;;;;;;IAsBE,0DAA0D;mBAA5C,OAAO,CAAC,qBAAqB,SAAS,CAAC,CAAC;GAmBzD;mCAEW,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BA5DjC,mBAAmB;sDAKS,kCAAkC;0CAD9C,eAAe;4BAF7B,kBAAkB;kCADZ,cAAc;gCAEhB,gCAAgC;uCAGyB,aAAa;+BAAb,aAAa;0CAAb,aAAa"}
+{"version":3,"file":"local-chain-facade.d.ts","sourceRoot":"","sources":["local-chain-facade.js"],"names":[],"mappings":"AA2BO,8CAVI,IAAI,yFACJ;IACV,gCAAoC,EAAE,gCAAgC,CAAC;IACvE,aAAiB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IAChD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,KAAS,EAAE,OAAO,YAAY,CAAC,CAAC;IAChC,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,QAAY,EAAE,QAAQ,CAAC;CACpB;;;;;;;;;;;;;;;;IA2BE,sDAAsD;mBAAxC,IAAI,qBAAqB,SAAS,CAAC,CAAC;GAsBrD;mCAEW,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BAtEjC,mBAAmB;sDAMS,kCAAkC;0CAD9C,eAAe;4BAH7B,kBAAkB;kCADZ,cAAc;gCAEhB,gCAAgC;8BAC7B,aAAa;uCAGyC,aAAa;yBAHnE,aAAa;+BAGyC,aAAa;0CAAb,aAAa"}

package/src/exos/local-chain-facade.js

@@ -1,5 +1,5 @@
 /** @file ChainAccount exo */
-import { V } from '@agoric/vow/vat.js';
+import { V, watch } from '@agoric/vow/vat.js';
 
 import { ChainFacadeI } from '../typeGuards.js';
 
@@ -8,6 +8,7 @@ import { ChainFacadeI } from '../typeGuards.js';
  * @import {TimerService} from '@agoric/time';
  * @import {Remote} from '@agoric/internal';
  * @import {LocalChain} from '@agoric/vats/src/localchain.js';
+ * @import {Vow, VowTools} from '@agoric/vow';
  * @import {OrchestrationService} from '../service.js';
  * @import {MakeLocalOrchestrationAccountKit} from './local-orchestration-account.js';
  * @import {ChainInfo, CosmosChainInfo, IBCConnectionInfo, OrchestrationAccount} from '../types.js';
@@ -21,11 +22,17 @@ import { ChainFacadeI } from '../typeGuards.js';
  *   storageNode: Remote<StorageNode>;
  *   timer: Remote<TimerService>;
  *   localchain: Remote<LocalChain>;
+ *   vowTools: VowTools;
  * }} powers
  */
 export const prepareLocalChainFacade = (
   zone,
-  { makeLocalOrchestrationAccountKit, localchain, storageNode },
+  {
+    makeLocalOrchestrationAccountKit,
+    localchain,
+    storageNode,
+    vowTools: { allVows },
+  },
 ) =>
   zone.exoClass(
     'LocalChainFacade',
@@ -37,29 +44,32 @@ export const prepareLocalChainFacade = (
       return { localChainInfo };
     },
     {
-      async getChainInfo() {
-        return this.state.localChainInfo;
+      getChainInfo() {
+        return watch(this.state.localChainInfo);
       },
 
       // FIXME parameterize on the remoteChainInfo to make()
       // That used to work but got lost in the migration to Exo
-      /** @returns {Promise<OrchestrationAccount<ChainInfo>>} */
-      async makeAccount() {
+      /** @returns {Vow<OrchestrationAccount<ChainInfo>>} */
+      makeAccount() {
         const { localChainInfo } = this.state;
         const lcaP = V(localchain).makeAccount();
-        const [lca, address] = await Promise.all([lcaP, V(lcaP).getAddress()]);
-        const { holder: account } = makeLocalOrchestrationAccountKit({
-          account: lca,
-          address: harden({
-            address,
-            chainId: localChainInfo.chainId,
-            addressEncoding: 'bech32',
-          }),
-          // FIXME storage path https://github.com/Agoric/agoric-sdk/issues/9066
-          storageNode,
+        // FIXME use watch() from vowTools
+        return watch(allVows([lcaP, V(lcaP).getAddress()]), {
+          onFulfilled: ([lca, address]) => {
+            const { holder: account } = makeLocalOrchestrationAccountKit({
+              account: lca,
+              address: harden({
+                address,
+                addressEncoding: 'bech32',
+                chainId: localChainInfo.chainId,
+              }),
+              // FIXME storage path https://github.com/Agoric/agoric-sdk/issues/9066
+              storageNode,
+            });
+            return account;
+          },
         });
-
-        return account;
       },
     },
   );

package/src/exos/orchestrator.d.ts

@@ -22,7 +22,7 @@ export function prepareOrchestratorKit(zone: Zone, { chainHub, localchain, makeL
     makeLocalChainFacadeWatcher: {
         /** @param {ChainInfo} agoricChainInfo */
         onFulfilled(agoricChainInfo: ChainInfo): import("@endo/exo").Guarded<{
-            getChainInfo(): Promise<Readonly<{
+            getChainInfo(): Vow<Readonly<{
                 chainId: string;
                 connections?: Record<string, IBCConnectionInfo>;
                 icqEnabled?: boolean;
@@ -30,7 +30,7 @@ export function prepareOrchestratorKit(zone: Zone, { chainHub, localchain, makeL
                     denom: string;
                 }>>;
             }>>;
-            makeAccount(): Promise<OrchestrationAccount<ChainInfo>>;
+            makeAccount(): Vow<OrchestrationAccount<ChainInfo>>;
         }>;
     };
     /**
@@ -45,7 +45,7 @@ export function prepareOrchestratorKit(zone: Zone, { chainHub, localchain, makeL
          * @param {[ChainInfo, ChainInfo, IBCConnectionInfo]} chainsAndConnection
          */
         onFulfilled([_agoricChainInfo, remoteChainInfo, connectionInfo]: [ChainInfo, ChainInfo, IBCConnectionInfo]): import("@endo/exo").Guarded<{
-            getChainInfo(): Promise<Readonly<{
+            getChainInfo(): Vow<Readonly<{
                 chainId: string;
                 connections?: Record<string, IBCConnectionInfo>;
                 icqEnabled?: boolean;
@@ -53,7 +53,7 @@ export function prepareOrchestratorKit(zone: Zone, { chainHub, localchain, makeL
                     denom: string;
                 }>>;
             }>>;
-            makeAccount(): Promise<OrchestrationAccount<ChainInfo>>;
+            makeAccount(): Vow<OrchestrationAccount<ChainInfo>>;
         }>;
     };
     orchestrator: {
@@ -84,6 +84,7 @@ import type { TimerService } from '@agoric/time';
 import type { VowTools } from '@agoric/vow';
 import type { ChainInfo } from '../types.js';
 import type { IBCConnectionInfo } from '../types.js';
+import type { Vow } from '@agoric/vow';
 import type { OrchestrationAccount } from '../types.js';
 import type { Chain } from '../types.js';
 //# sourceMappingURL=orchestrator.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"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;yBAVxF,aAAa;0CAU8D,aAAa;2BAAb,aAAa"}

package/src/exos/remote-chain-facade.d.ts

@@ -1,8 +1,9 @@
-export function prepareRemoteChainFacade(zone: Zone, { makeCosmosOrchestrationAccount, orchestration, storageNode, timer }: {
+export function prepareRemoteChainFacade(zone: Zone, { makeCosmosOrchestrationAccount, orchestration, storageNode, timer, vowTools: { allVows }, }: {
     makeCosmosOrchestrationAccount: ReturnType<typeof prepareCosmosOrchestrationAccount>;
     orchestration: Remote<OrchestrationService>;
     storageNode: Remote<StorageNode>;
     timer: Remote<TimerService>;
+    vowTools: VowTools;
 }): (remoteChainInfo: Readonly<{
     chainId: string;
     connections?: Record<string, IBCConnectionInfo>;
@@ -11,7 +12,7 @@ export function prepareRemoteChainFacade(zone: Zone, { makeCosmosOrchestrationAc
         denom: string;
     }>>;
 }>, connectionInfo: IBCConnectionInfo) => import("@endo/exo").Guarded<{
-    getChainInfo(): Promise<Readonly<{
+    getChainInfo(): Vow<Readonly<{
         chainId: string;
         connections?: Record<string, IBCConnectionInfo>;
         icqEnabled?: boolean;
@@ -19,8 +20,8 @@ export function prepareRemoteChainFacade(zone: Zone, { makeCosmosOrchestrationAc
             denom: string;
         }>>;
     }>>;
-    /** @returns {Promise<OrchestrationAccount<ChainInfo>>} */
-    makeAccount(): Promise<OrchestrationAccount<ChainInfo>>;
+    /** @returns {Vow<OrchestrationAccount<ChainInfo>>} */
+    makeAccount(): Vow<OrchestrationAccount<ChainInfo>>;
 }>;
 export type MakeRemoteChainFacade = ReturnType<typeof prepareRemoteChainFacade>;
 import type { Zone } from '@agoric/base-zone';
@@ -28,7 +29,9 @@ import type { prepareCosmosOrchestrationAccount } from './cosmos-orchestration-a
 import type { OrchestrationService } from '../service.js';
 import type { Remote } from '@agoric/internal';
 import type { TimerService } from '@agoric/time';
+import type { VowTools } from '@agoric/vow';
 import type { IBCConnectionInfo } from '../types.js';
+import type { Vow } from '@agoric/vow';
 import type { ChainInfo } from '../types.js';
 import type { OrchestrationAccount } from '../types.js';
 //# sourceMappingURL=remote-chain-facade.d.ts.map

package/src/exos/remote-chain-facade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote-chain-facade.d.ts","sourceRoot":"","sources":["remote-chain-facade.js"],"names":[],"mappings":"AAgCO,+CAVI,IAAI,yEACJ;IACV,8BAAkC,EAAE,UAAU,CAC9C,wCAA8C,CACzC,CAAC;IACN,aAAiB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IAChD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,KAAS,EAAE,OAAO,YAAY,CAAC,CAAC;CAC7B;;;;;;;;;;;;;;;;IAwBE,0DAA0D;mBAA5C,OAAO,CAAC,qBAAqB,SAAS,CAAC,CAAC;GAwBzD;oCAEW,UAAU,CAAC,OAAO,wBAAwB,CAAC;0BAzElC,mBAAmB;uDAIU,mCAAmC;0CADhD,eAAe;4BAD7B,kBAAkB;kCADZ,cAAc;uCAIyC,aAAa;+BAAb,aAAa;0CAAb,aAAa"}
+{"version":3,"file":"remote-chain-facade.d.ts","sourceRoot":"","sources":["remote-chain-facade.js"],"names":[],"mappings":"AAkCO,+CAXI,IAAI,iGACJ;IACV,8BAAkC,EAAE,UAAU,CAC9C,wCAA8C,CACzC,CAAC;IACN,aAAiB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IAChD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,KAAS,EAAE,OAAO,YAAY,CAAC,CAAC;IAChC,QAAY,EAAE,QAAQ,CAAC;CACpB;;;;;;;;;;;;;;;;IA8BE,sDAAsD;mBAAxC,IAAI,qBAAqB,SAAS,CAAC,CAAC;GA6BrD;oCAEW,UAAU,CAAC,OAAO,wBAAwB,CAAC;0BAtFlC,mBAAmB;uDAKU,mCAAmC;0CADhD,eAAe;4BAF7B,kBAAkB;kCADZ,cAAc;8BAEb,aAAa;uCAGyC,aAAa;yBAHnE,aAAa;+BAGyC,aAAa;0CAAb,aAAa"}

package/src/exos/remote-chain-facade.js

@@ -1,6 +1,6 @@
 /** @file ChainAccount exo */
 import { makeTracer } from '@agoric/internal';
-import { V } from '@agoric/vow/vat.js';
+import { V, watch } from '@agoric/vow/vat.js';
 
 import { ChainFacadeI } from '../typeGuards.js';
 
@@ -8,6 +8,7 @@ import { ChainFacadeI } from '../typeGuards.js';
  * @import {Zone} from '@agoric/base-zone';
  * @import {TimerService} from '@agoric/time';
  * @import {Remote} from '@agoric/internal';
+ * @import {Vow, VowTools} from '@agoric/vow';
  * @import {OrchestrationService} from '../service.js';
  * @import {prepareCosmosOrchestrationAccount} from './cosmos-orchestration-account.js';
  * @import {ChainInfo, CosmosChainInfo, IBCConnectionInfo, OrchestrationAccount} from '../types.js';
@@ -28,11 +29,18 @@ const anyVal = null;
  *   orchestration: Remote<OrchestrationService>;
  *   storageNode: Remote<StorageNode>;
  *   timer: Remote<TimerService>;
+ *   vowTools: VowTools;
  * }} powers
  */
 export const prepareRemoteChainFacade = (
   zone,
-  { makeCosmosOrchestrationAccount, orchestration, storageNode, timer },
+  {
+    makeCosmosOrchestrationAccount,
+    orchestration,
+    storageNode,
+    timer,
+    vowTools: { allVows },
+  },
 ) =>
   zone.exoClass(
     'RemoteChainFacade',
@@ -46,33 +54,38 @@ export const prepareRemoteChainFacade = (
       return { remoteChainInfo, connectionInfo };
     },
     {
-      async getChainInfo() {
-        return this.state.remoteChainInfo;
+      getChainInfo() {
+        return watch(this.state.remoteChainInfo);
       },
 
       // FIXME parameterize on the remoteChainInfo to make()
       // That used to work but got lost in the migration to Exo
-      /** @returns {Promise<OrchestrationAccount<ChainInfo>>} */
-      async makeAccount() {
+      /** @returns {Vow<OrchestrationAccount<ChainInfo>>} */
+      makeAccount() {
         const { remoteChainInfo, connectionInfo } = this.state;
+        const stakingDenom = remoteChainInfo.stakingTokens?.[0]?.denom;
+        if (!stakingDenom) {
+          // FIXME methods that return vows must not throw synchronously
+          throw Fail`chain info lacks staking denom`;
+        }
 
-        const icaAccount = await V(orchestration).makeAccount(
+        const icaP = V(orchestration).makeAccount(
           remoteChainInfo.chainId,
           connectionInfo.id,
           connectionInfo.counterparty.connection_id,
         );
 
-        const address = await V(icaAccount).getAddress();
-
-        const stakingDenom = remoteChainInfo.stakingTokens?.[0]?.denom;
-        if (!stakingDenom) {
-          throw Fail`chain info lacks staking denom`;
-        }
-        return makeCosmosOrchestrationAccount(address, stakingDenom, {
-          account: icaAccount,
-          storageNode,
-          icqConnection: anyVal,
-          timer,
+        // FIXME use watch() from vowTools
+        return watch(allVows([icaP, V(icaP).getAddress()]), {
+          onFulfilled: ([account, address]) => {
+            return makeCosmosOrchestrationAccount(address, stakingDenom, {
+              account,
+              storageNode,
+              // FIXME provide real ICQ connection
+              icqConnection: anyVal,
+              timer,
+            });
+          },
         });
       },
     },

package/src/proposals/revise-chain-info.d.ts

@@ -0,0 +1,21 @@
+export function reviseChainInfo({ consume: { agoricNamesAdmin } }: BootstrapPowers, { options: { chainInfo } }: {
+    options: {
+        chainInfo: Record<string, CosmosChainInfo>;
+    };
+}): Promise<void>;
+export function getManifestForReviseChains(_powers: any, { chainInfo }: {
+    chainInfo: any;
+}): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                agoricNamesAdmin: boolean;
+            };
+        };
+    };
+    options: {
+        chainInfo: any;
+    };
+};
+import type { CosmosChainInfo } from '../types.js';
+//# sourceMappingURL=revise-chain-info.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"revise-chain-info.d.ts","sourceRoot":"","sources":["revise-chain-info.js"],"names":[],"mappings":"AAeO,mEAHI,eAAe,8BACf;IAAE,OAAO,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;KAAE,CAAA;CAAE,iBAgBrE;AAGM;;;;;;;;;;;;;EAWL;qCAtCiC,aAAa"}

package/src/proposals/revise-chain-info.js

@@ -0,0 +1,44 @@
+import { makeTracer } from '@agoric/internal';
+import { registerChain } from '../chain-info.js';
+
+const trace = makeTracer('ReviseChainInfo', true);
+
+/** @import {CosmosChainInfo} from '../types.js'; */
+
+/**
+ * This will add news values AND overwrite any existing values. Voters on a
+ * proposal of core-eval must be careful not to overwrite any values operating
+ * in production.
+ *
+ * @param {BootstrapPowers} powers
+ * @param {{ options: { chainInfo: Record<string, CosmosChainInfo> } }} opt
+ */
+export const reviseChainInfo = async (
+  { consume: { agoricNamesAdmin } },
+  { options: { chainInfo } },
+) => {
+  trace('init-chainInfo');
+
+  assert(chainInfo, 'chainInfo is required');
+
+  trace(chainInfo);
+
+  // Now register the names
+  for await (const [name, info] of Object.entries(chainInfo)) {
+    await registerChain(agoricNamesAdmin, name, info, trace);
+  }
+};
+harden(reviseChainInfo);
+
+export const getManifestForReviseChains = (_powers, { chainInfo }) => ({
+  manifest: {
+    [reviseChainInfo.name]: {
+      consume: {
+        agoricNamesAdmin: true,
+      },
+    },
+  },
+  options: {
+    chainInfo,
+  },
+});

package/src/typeGuards.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAGA;;;;GAIG;;;;;;;;;;;;;;;;;;;;;AAiBH,8DAAkE;;;;;AAOlE,uEAUE;AAEF,iEAA4C;AAC5C,mEAQG;AACH,oEAA+C;AAC/C,sEAYG;AAEH,oEAUE;AAGF,8DAAsC;AACtC,sEAAuE;AACvE,0DAAqC;AAErC,8DAAsC;;;;;;AAItC,mBAAmB;AACnB;;;GAGG"}
+{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAIA;;;;GAIG;;;;;;;;;;;;;;;;;;;;;AAiBH,8DAAkE;;;;;AAOlE,uEAUE;AAEF,iEAA4C;AAC5C,mEAQG;AACH,oEAA+C;AAC/C,sEAYG;AAEH,oEAUE;AAGF,8DAAsC;AACtC,sEAAuE;AACvE,0DAAqC;AAErC,8DAAsC;;;;;;AAItC,mBAAmB;AACnB;;;GAGG"}

package/src/typeGuards.js

@@ -1,4 +1,5 @@
 import { AmountShape } from '@agoric/ertp';
+import { VowShape } from '@agoric/vow';
 import { M } from '@endo/patterns';
 
 export const ConnectionHandlerI = M.interface('ConnectionHandler', {
@@ -89,6 +90,6 @@ export const DenomAmountShape = { denom: DenomShape, value: M.bigint() };
 
 /** @see {Chain} */
 export const ChainFacadeI = M.interface('ChainFacade', {
-  getChainInfo: M.callWhen().returns(ChainInfoShape),
-  makeAccount: M.callWhen().returns(M.remotable('OrchestrationAccount')),
+  getChainInfo: M.call().returns(VowShape),
+  makeAccount: M.call().returns(VowShape),
 });

package/src/utils/registry.d.ts

@@ -0,0 +1,13 @@
+export function convertChainInfo(registry: Pick<ChainRegistryClient, "chains" | "ibcData">): Promise<{
+    [k: string]: Readonly<{
+        chainId: string;
+        connections?: Record<string, IBCConnectionInfo>;
+        icqEnabled?: boolean;
+        stakingTokens?: Readonly<Array<{
+            denom: string;
+        }>>;
+    }>;
+}>;
+import type { ChainRegistryClient } from '@chain-registry/client';
+import type { IBCConnectionInfo } from '../cosmos-api.js';
+//# sourceMappingURL=registry.d.ts.map

package/src/utils/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["registry.js"],"names":[],"mappings":"AAwFO,2CAFI,IAAI,CAAC,mBAAmB,EAAE,QAAQ,GAAG,SAAS,CAAC;;;;;;;;;GA4CzD;yCAxHqC,wBAAwB;uCACT,kBAAkB"}

package/src/utils/registry.js

@@ -0,0 +1,131 @@
+import {
+  State as IBCChannelState,
+  Order,
+} from '@agoric/cosmic-proto/ibc/core/channel/v1/channel.js';
+import { State as IBCConnectionState } from '@agoric/cosmic-proto/ibc/core/connection/v1/connection.js';
+import assert from 'node:assert';
+
+/**
+ * @import {IBCChannelID, IBCConnectionID} from '@agoric/vats';
+ * @import {Chain, IBCInfo} from '@chain-registry/types';
+ * @import {ChainRegistryClient} from '@chain-registry/client';
+ * @import {CosmosChainInfo, IBCConnectionInfo} from '../cosmos-api.js';
+ */
+
+/**
+ * @param {IBCInfo} ibcInfo
+ * @param {string} name
+ * @param {Record<string, CosmosChainInfo>} chainInfo
+ * @returns {[string, IBCConnectionInfo] | []}
+ */
+function toConnectionEntry(ibcInfo, name, chainInfo) {
+  // IbcInfo encodes the undirected edge as a tuple of (chain_1, chain_2) in alphabetical order
+  const fromChain1 = ibcInfo.chain_1.chain_name === name;
+  const [from, to] = fromChain1
+    ? [ibcInfo.chain_1, ibcInfo.chain_2]
+    : [ibcInfo.chain_2, ibcInfo.chain_1];
+  assert.equal(from.chain_name, name);
+  const transferChannels = ibcInfo.channels.filter(
+    c =>
+      c.chain_1.port_id === 'transfer' &&
+      // @ts-expect-error tags does not specify keys
+      c.tags?.preferred,
+  );
+  if (transferChannels.length === 0) {
+    console.warn(
+      'no transfer channel for [',
+      from.chain_name,
+      to.chain_name,
+      ']',
+      '(skipping)',
+    );
+    return [];
+  }
+  if (transferChannels.length > 1) {
+    console.warn(
+      'multiple preferred transfer channels [',
+      from.chain_name,
+      to.chain_name,
+      ']:',
+      transferChannels,
+      '(choosing first)',
+    );
+  }
+  const [channel] = transferChannels;
+  const [channelFrom, channelTo] = fromChain1
+    ? [channel.chain_2, channel.chain_1]
+    : [channel.chain_1, channel.chain_2];
+  const record = {
+    id: /** @type {IBCConnectionID} */ (from.connection_id),
+    client_id: from.client_id,
+    counterparty: {
+      client_id: to.client_id,
+      connection_id: /** @type {IBCConnectionID} */ (to.connection_id),
+      prefix: {
+        key_prefix: 'FIXME',
+      },
+    },
+    state: IBCConnectionState.STATE_OPEN, // XXX presumably
+    transferChannel: {
+      channelId: /** @type {IBCChannelID} */ (channelFrom.channel_id),
+      portId: channelFrom.port_id,
+      counterPartyChannelId: /** @type {IBCChannelID} */ (channelTo.channel_id),
+      counterPartyPortId: channelTo.port_id,
+      // FIXME mapping, our guard expects a numerical enum
+      ordering: Order.ORDER_NONE_UNSPECIFIED,
+      state: IBCChannelState.STATE_OPEN, // XXX presumably
+      version: channel.version,
+    },
+  };
+  const destChainId = chainInfo[to.chain_name].chainId;
+  return [destChainId, record];
+}
+
+/**
+ * Converts the given chain info to our local config format
+ *
+ * @param {Pick<ChainRegistryClient, 'chains' | 'ibcData'>} registry
+ */
+export const convertChainInfo = async registry => {
+  /** @type {Record<string, CosmosChainInfo>} */
+  const chainInfo = {};
+
+  for (const chain of registry.chains) {
+    console.log('processing info', chain.chain_name);
+    chainInfo[chain.chain_name] = {
+      chainId: chain.chain_id,
+      stakingTokens: chain.staking?.staking_tokens,
+      // UNTIL https://github.com/Agoric/agoric-sdk/issues/9326
+      icqEnabled: chain.chain_name === 'osmosis',
+    };
+  }
+
+  // XXX probably easier to keep ibc separate
+  const ibcLookup = {};
+  for (const ibc of registry.ibcData) {
+    ibcLookup[ibc.chain_1.chain_name] ||= [];
+    ibcLookup[ibc.chain_2.chain_name] ||= [];
+
+    ibcLookup[ibc.chain_1.chain_name].push(ibc);
+    ibcLookup[ibc.chain_2.chain_name].push(ibc);
+  }
+
+  const chainNames = registry.chains.map(c => c.chain_name).sort();
+
+  // iterate this after chainInfo is filled out
+  for (const name of chainNames) {
+    console.log('processing connections', name);
+
+    const ibcData = ibcLookup[name];
+    const connections = Object.fromEntries(
+      ibcData
+        .map(datum => toConnectionEntry(datum, name, chainInfo))
+        // sort alphabetically for consistency
+        .sort(([a], [b]) => (a && b ? a.localeCompare(b) : 0)),
+    );
+    chainInfo[name] = { ...chainInfo[name], connections };
+  }
+
+  // return object with insertion in alphabetical order of chain name
+  return Object.fromEntries(chainNames.map(name => [name, chainInfo[name]]));
+};

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;;;;;;;;;;;;;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"}
+{"version":3,"file":"start-helper.d.ts","sourceRoot":"","sources":["start-helper.js"],"names":[],"mappings":"AAwCO,0CALI,GAAG,WACH,OAAO,gBACP,mBAAmB,cACnB,UAAU;;;;;;;;;;;;;iKA4DT,GAAa,kCAED,GACxB;EAKC;kCApFY;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"}

package/src/utils/start-helper.js

@@ -77,6 +77,7 @@ export const provideOrchestration = (
     orchestration: remotePowers.orchestrationService,
     storageNode: remotePowers.storageNode,
     timer: remotePowers.timerService,
+    vowTools,
   });
 
   const makeLocalChainFacade = prepareLocalChainFacade(zone, {
@@ -86,6 +87,7 @@ export const provideOrchestration = (
     storageNode: remotePowers.storageNode,
     orchestration: remotePowers.orchestrationService,
     timer: remotePowers.timerService,
+    vowTools,
   });
 
   const facade = makeOrchestrationFacade({