@agoric/orchestration 0.1.1-dev-217005a.0 → 0.1.1-dev-b196804.0

package/src/proposals/start-stakeAtom.js

@@ -1,6 +1,8 @@
 import { makeTracer } from '@agoric/internal';
 import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
-import { heapVowE as E } from '@agoric/vow/vat.js';
+import { prepareVowTools } from '@agoric/vow';
+import { makeHeapZone } from '@agoric/zone';
+import { E } from '@endo/far';
 import { makeChainHub } from '../exos/chain-hub.js';
 
 /**
@@ -27,7 +29,7 @@ export const startStakeAtom = async ({
     board,
     chainStorage,
     chainTimerService,
-    orchestration,
+    cosmosInterchainService,
     startUpgradable,
   },
   installation: {
@@ -44,9 +46,10 @@ export const startStakeAtom = async ({
   const storageNode = await makeStorageNodeChild(chainStorage, VSTORAGE_PATH);
   const marshaller = await E(board).getPublishingMarshaller();
 
-  const chainHub = makeChainHub(await agoricNames);
+  const vt = prepareVowTools(makeHeapZone());
+  const chainHub = makeChainHub(await agoricNames, vt);
 
-  const [_, cosmoshub, connectionInfo] = await E.when(
+  const [_, cosmoshub, connectionInfo] = await vt.when(
     chainHub.getChainsAndConnection('agoric', 'cosmoshub'),
   );
 
@@ -62,7 +65,7 @@ export const startStakeAtom = async ({
       icqEnabled: cosmoshub.icqEnabled,
     },
     privateArgs: {
-      orchestration: await orchestration,
+      cosmosInterchainService: await cosmosInterchainService,
       storageNode,
       marshaller,
       timer: await chainTimerService,
@@ -86,7 +89,7 @@ export const getManifestForStakeAtom = (
           board: true,
           chainStorage: true,
           chainTimerService: true,
-          orchestration: true,
+          cosmosInterchainService: true,
           startUpgradable: true,
         },
         installation: {

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

@@ -1,8 +1,8 @@
-export function startStakeOsmo({ consume: { agoricNames, board, chainStorage, chainTimerService, orchestration, startUpgradable, }, installation: { consume: { stakeIca }, }, instance: { produce: { stakeOsmo: produceInstance }, }, }: BootstrapPowers & {
+export function startStakeOsmo({ consume: { agoricNames, board, chainStorage, chainTimerService, cosmosInterchainService, startUpgradable, }, installation: { consume: { stakeIca }, }, instance: { produce: { stakeOsmo: produceInstance }, }, }: BootstrapPowers & {
     installation: {
         consume: {
             stakeIca: Installation<(zcf: ZCF<StakeIcaTerms>, privateArgs: {
-                orchestration: import("../service.js").OrchestrationService;
+                cosmosInterchainService: import("../types.js").CosmosInterchainService;
                 storageNode: StorageNode;
                 marshaller: Marshaller;
                 timer: import("@agoric/time").TimerService;
@@ -82,7 +82,7 @@ export function getManifestForStakeOsmo({ restoreRef }: {
                 board: boolean;
                 chainStorage: boolean;
                 chainTimerService: boolean;
-                orchestration: boolean;
+                cosmosInterchainService: boolean;
                 startUpgradable: boolean;
             };
             installation: {

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,iBAqDH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BN"}
+{"version":3,"file":"start-stakeOsmo.d.ts","sourceRoot":"","sources":["start-stakeOsmo.js"],"names":[],"mappings":"AAyBO,mPAVI,eAAe,GAAG;IAC5B,YAAgB,EAAE;QAClB,OAAa,EAAE;YACf,QAAgB,EAAE,YAAY,CAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA0D,CACjD,CAAC;SACH,CAAC;KACH,CAAC;CACH,iBAsDH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BN"}

package/src/proposals/start-stakeOsmo.js

@@ -1,6 +1,8 @@
 import { makeTracer } from '@agoric/internal';
 import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
-import { heapVowE as E } from '@agoric/vow/vat.js';
+import { prepareVowTools } from '@agoric/vow';
+import { makeHeapZone } from '@agoric/zone';
+import { E } from '@endo/far';
 import { makeChainHub } from '../exos/chain-hub.js';
 
 /**
@@ -27,7 +29,7 @@ export const startStakeOsmo = async ({
     board,
     chainStorage,
     chainTimerService,
-    orchestration,
+    cosmosInterchainService,
     startUpgradable,
   },
   installation: {
@@ -45,9 +47,10 @@ export const startStakeOsmo = async ({
   const storageNode = await makeStorageNodeChild(chainStorage, VSTORAGE_PATH);
   const marshaller = await E(board).getPublishingMarshaller();
 
-  const chainHub = makeChainHub(await agoricNames);
+  const vt = prepareVowTools(makeHeapZone());
+  const chainHub = makeChainHub(await agoricNames, vt);
 
-  const [_, osmosis, connectionInfo] = await E.when(
+  const [_, osmosis, connectionInfo] = await vt.when(
     chainHub.getChainsAndConnection('agoric', 'osmosis'),
   );
 
@@ -63,7 +66,7 @@ export const startStakeOsmo = async ({
       icqEnabled: osmosis.icqEnabled,
     },
     privateArgs: {
-      orchestration: await orchestration,
+      cosmosInterchainService: await cosmosInterchainService,
       storageNode,
       marshaller,
       timer: await chainTimerService,
@@ -87,7 +90,7 @@ export const getManifestForStakeOsmo = (
           board: true,
           chainStorage: true,
           chainTimerService: true,
-          orchestration: true,
+          cosmosInterchainService: true,
           startUpgradable: true,
         },
         installation: {

package/src/types.d.ts

@@ -6,6 +6,6 @@ export type * from './exos/chain-account-kit.js';
 export type * from './exos/icq-connection-kit.js';
 export type * from './internal.js';
 export type * from './orchestration-api.js';
-export type * from './service.js';
+export type * from './exos/cosmos-interchain-service.js';
 export type * from './vat-orchestration.js';
 //# sourceMappingURL=types.d.ts.map

package/src/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":"AAAA,gGAAgG;AAEhG,mBAAmB,iBAAiB,CAAC;AACrC,mBAAmB,iBAAiB,CAAC;AACrC,mBAAmB,mBAAmB,CAAC;AACvC,mBAAmB,6BAA6B,CAAC;AACjD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,eAAe,CAAC;AACnC,mBAAmB,wBAAwB,CAAC;AAC5C,mBAAmB,cAAc,CAAC;AAClC,mBAAmB,wBAAwB,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":"AAAA,gGAAgG;AAEhG,mBAAmB,iBAAiB,CAAC;AACrC,mBAAmB,iBAAiB,CAAC;AACrC,mBAAmB,mBAAmB,CAAC;AACvC,mBAAmB,6BAA6B,CAAC;AACjD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,eAAe,CAAC;AACnC,mBAAmB,wBAAwB,CAAC;AAC5C,mBAAmB,qCAAqC,CAAC;AACzD,mBAAmB,wBAAwB,CAAC"}

package/src/types.ts

@@ -7,5 +7,5 @@ export type * from './exos/chain-account-kit.js';
 export type * from './exos/icq-connection-kit.js';
 export type * from './internal.js';
 export type * from './orchestration-api.js';
-export type * from './service.js';
+export type * from './exos/cosmos-interchain-service.js';
 export type * from './vat-orchestration.js';

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

@@ -17,8 +17,9 @@ export function provideOrchestration(zcf: ZCF, baggage: Baggage, remotePowers: O
         allVows: (maybeVows: import("@agoric/vow").EVow<unknown>[]) => import("@agoric/vow").Vow<any[]>;
         asVow: <T extends unknown>(fn: (...args: any[]) => import("@agoric/vow").Vow<Awaited<T>> | Awaited<T> | import("@agoric/vow").PromiseVow<T>) => import("@agoric/vow").Vow<Awaited<T>>;
         asPromise: import("@agoric/vow").AsPromiseFunction;
+        retriable: <T>(fnZone: Zone, name: string, fn: (...args: unknown[]) => import("@agoric/vow").ERef<T>) => (...args: unknown[]) => import("@agoric/vow").Vow<T>;
     };
-    zone: import("@agoric/base-zone").Zone;
+    zone: Zone;
     orchestrate<GuestReturn, HostReturn, GuestContext, HostContext, GuestArgs extends any[], HostArgs extends any[]>(durableName: string, hostCtx: HostContext, guestFn: (guestOrc: import("../orchestration-api.js").Orchestrator, guestCtx: GuestContext, ...args: GuestArgs) => Promise<GuestReturn>): (...args: HostArgs) => Promise<HostReturn>;
     adminAsyncFlow: import("@endo/exo").Guarded<{
         getFailures(): import("@endo/patterns").CopyMap<any, import("@endo/pass-style").Passable>;
@@ -26,17 +27,22 @@ export function provideOrchestration(zcf: ZCF, baggage: Baggage, remotePowers: O
         getFlowForOutcomeVow(outcomeVow: any): any;
     }>;
 };
+export function withOrchestration<CT extends Record<string, unknown>, PA extends OrchestrationPowers & {
+    marshaller: Marshaller;
+}, R>(contractFn: (zcf: ZCF<CT>, privateArgs: PA, zone: Zone, tools: OrchestrationTools) => Promise<R>): (zcf: ZCF<CT>, privateArgs: PA, baggage: Baggage) => Promise<R>;
 export type OrchestrationPowers = {
     localchain: Remote<LocalChain>;
-    orchestrationService: Remote<OrchestrationService>;
+    orchestrationService: Remote<CosmosInterchainService>;
     storageNode: Remote<StorageNode>;
     timerService: Remote<TimerService>;
     agoricNames: Remote<NameHub>;
 };
+export type OrchestrationTools = Omit<ReturnType<typeof provideOrchestration>, "zone">;
 import type { Baggage } from '@agoric/vat-data';
+import type { Zone } from '@agoric/zone';
 import type { LocalChain } from '@agoric/vats/src/localchain.js';
 import type { Remote } from '@agoric/vow';
-import type { OrchestrationService } from '../service.js';
+import type { CosmosInterchainService } from '../exos/cosmos-interchain-service.js';
 import type { TimerService } from '@agoric/time';
 import type { NameHub } from '@agoric/vats';
 //# sourceMappingURL=start-helper.d.ts.map

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;;;;;;;;;;;;;;;;;wCA4Cd,GAAG;;;;4PA4BiB,GAAa,4CAGP,GAAG;;;;;;EAFnC;kCAzFY;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":"AAyCO,0CALI,GAAG,WACH,OAAO,gBACP,mBAAmB,cACnB,UAAU;;;;;;;;;;;;;;;;;wCAwC0B,GAAG;;wDA9Cd,GAAG,uDAC9B,GAAG;;;4PAsEK,GAAa,4CAK1B,GAAG;;;;;;EAaN;AAuBM,kCAdgC,EAAE,SAA3B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAE,EAGhC,EAAE,SAFM,mBAAmB,GAAG;IACnC,UAAc,EAAE,UAAU,CAAC;CACvB,EACQ,CAAC,cACH,CACV,GAAO,EAAE,GAAG,CAAC,EAAE,CAAC,EAChB,WAAe,EAAE,EAAE,EACnB,IAAQ,EAAE,IAAI,EACd,KAAS,EAAE,kBAAkB,KACtB,OAAO,CAAC,CAAC,CAAC,GACL,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,CAYzE;kCAnIU;IACZ,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,oBAAwB,EAAE,OAAO,uBAAuB,CAAC,CAAC;IAC1D,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;CAC9B;iCAgGU,IAAI,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,EAAE,MAAM,CAAC;6BA9GzC,kBAAkB;0BAGrB,cAAc;gCALR,gCAAgC;4BAIpC,aAAa;6CAEI,sCAAsC;kCALrC,cAAc;6BAE/B,cAAc"}

package/src/utils/start-helper.js

@@ -16,13 +16,14 @@ import { prepareLocalChainFacade } from '../exos/local-chain-facade.js';
  * @import {Baggage} from '@agoric/vat-data';
  * @import {NameHub} from '@agoric/vats';
  * @import {Remote} from '@agoric/vow';
- * @import {OrchestrationService} from '../service.js';
+ * @import {Zone} from '@agoric/zone';
+ * @import {CosmosInterchainService} from '../exos/cosmos-interchain-service.js';
  */
 
 /**
  * @typedef {{
  *   localchain: Remote<LocalChain>;
- *   orchestrationService: Remote<OrchestrationService>;
+ *   orchestrationService: Remote<CosmosInterchainService>;
  *   storageNode: Remote<StorageNode>;
  *   timerService: Remote<TimerService>;
  *   agoricNames: Remote<NameHub>;
@@ -48,16 +49,27 @@ export const provideOrchestration = (
     baggage,
   }));
 
-  const zone = makeDurableZone(baggage);
+  // separate zones
+  const zones = (() => {
+    const zone = makeDurableZone(baggage);
+    return {
+      asyncFlow: zone.subZone('asyncFlow'),
+      /** for contract-provided names */
+      contract: zone.subZone('contract'),
+      orchestration: zone.subZone('orchestration'),
+      vows: zone.subZone('vows'),
+    };
+  })();
+
   const { agoricNames, timerService } = remotePowers;
 
-  const chainHub = makeChainHub(agoricNames);
+  const vowTools = prepareVowTools(zones.vows);
 
-  const vowTools = prepareVowTools(zone.subZone('vows'));
+  const chainHub = makeChainHub(agoricNames, vowTools);
 
   const { makeRecorderKit } = prepareRecorderKitMakers(baggage, marshaller);
   const makeLocalOrchestrationAccountKit = prepareLocalOrchestrationAccountKit(
-    zone,
+    zones.orchestration,
     makeRecorderKit,
     zcf,
     timerService,
@@ -65,19 +77,18 @@ export const provideOrchestration = (
     chainHub,
   );
 
-  const asyncFlowTools = prepareAsyncFlowTools(zone.subZone('asyncFlow'), {
+  const asyncFlowTools = prepareAsyncFlowTools(zones.asyncFlow, {
     vowTools,
   });
 
   const makeCosmosOrchestrationAccount = prepareCosmosOrchestrationAccount(
-    // FIXME what zone?
-    zone,
+    zones.orchestration,
     makeRecorderKit,
     vowTools,
     zcf,
   );
 
-  const makeRemoteChainFacade = prepareRemoteChainFacade(zone, {
+  const makeRemoteChainFacade = prepareRemoteChainFacade(zones.orchestration, {
     makeCosmosOrchestrationAccount,
     orchestration: remotePowers.orchestrationService,
     storageNode: remotePowers.storageNode,
@@ -85,7 +96,7 @@ export const provideOrchestration = (
     vowTools,
   });
 
-  const makeLocalChainFacade = prepareLocalChainFacade(zone, {
+  const makeLocalChainFacade = prepareLocalChainFacade(zones.orchestration, {
     makeLocalOrchestrationAccountKit,
     localchain: remotePowers.localchain,
     // FIXME what path?
@@ -97,7 +108,7 @@ export const provideOrchestration = (
 
   const facade = makeOrchestrationFacade({
     zcf,
-    zone,
+    zone: zones.orchestration,
     chainHub,
     makeLocalOrchestrationAccountKit,
     makeRecorderKit,
@@ -108,6 +119,38 @@ export const provideOrchestration = (
     vowTools,
     ...remotePowers,
   });
-  return { ...facade, chainHub, vowTools, zone };
+  return { ...facade, chainHub, vowTools, zone: zones.contract };
 };
 harden(provideOrchestration);
+
+/** @typedef {Omit<ReturnType<typeof provideOrchestration>, 'zone'>} OrchestrationTools */
+
+/**
+ * Simplifies contract functions for Orchestration by wrapping a simpler
+ * function with all the tools it needs in order to use Orchestration.
+ *
+ * @template {Record<string, unknown>} CT
+ * @template {OrchestrationPowers & {
+ *   marshaller: Marshaller;
+ * }} PA
+ * @template R
+ * @param {(
+ *   zcf: ZCF<CT>,
+ *   privateArgs: PA,
+ *   zone: Zone,
+ *   tools: OrchestrationTools,
+ * ) => Promise<R>} contractFn
+ * @returns {(zcf: ZCF<CT>, privateArgs: PA, baggage: Baggage) => Promise<R>} a
+ *   Zoe start function
+ */
+export const withOrchestration =
+  contractFn => async (zcf, privateArgs, baggage) => {
+    const { zone, ...tools } = provideOrchestration(
+      zcf,
+      baggage,
+      privateArgs,
+      privateArgs.marshaller,
+    );
+    return contractFn(zcf, privateArgs, zone, tools);
+  };
+harden(withOrchestration);

package/src/vat-orchestration.d.ts

@@ -1,58 +1,16 @@
 export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
     /** @param {Partial<OrchestrationPowers>} [initialPowers] */
-    makeOrchestrationKit(initialPowers?: Partial<OrchestrationPowers> | undefined): import("@endo/exo").GuardedKit<{
-        requestICAChannelWatcher: {
-            onFulfilled(port: import("@agoric/network").Port, { chainId, remoteConnAddr }: {
-                chainId: string;
-                remoteConnAddr: import("@agoric/vats/tools/ibc-utils.js").RemoteIbcAddress;
-            }): import("@agoric/vow").Vow<any>;
-        };
-        requestICQChannelWatcher: {
-            onFulfilled(port: import("@agoric/network").Port, { remoteConnAddr, controllerConnectionId }: {
-                remoteConnAddr: import("@agoric/vats/tools/ibc-utils.js").RemoteIbcAddress;
-                controllerConnectionId: import("@agoric/vats").IBCConnectionID;
-            }): import("@agoric/vow").Vow<any>;
-        };
-        channelOpenWatcher: {
-            onFulfilled(_connection: import("@agoric/network").Connection, { connectionKit, returnFacet, saveICQConnection }: {
-                connectionKit: ConnectionKit;
-                returnFacet: string;
-                saveICQConnection?: import("@agoric/vats").IBCConnectionID;
-            }): any;
-        };
-        public: {
-            makeAccount(chainId: string, hostConnectionId: import("@agoric/vats").IBCConnectionID, controllerConnectionId: import("@agoric/vats").IBCConnectionID): import("@agoric/vow").Vow<import("./cosmos-api.js").IcaAccount>;
-            provideICQConnection(controllerConnectionId: import("@agoric/vats").IBCConnectionID): import("@agoric/vow").Vow<import("./types.js").ICQConnection> | import("./types.js").ICQConnection;
-        };
+    makeCosmosInterchainService(initialPowers?: Partial<OrchestrationPowers> | undefined): import("@endo/exo").Guarded<{
+        makeAccount(chainId: string, hostConnectionId: import("@agoric/vats").IBCConnectionID, controllerConnectionId: import("@agoric/vats").IBCConnectionID): import("@agoric/vow").Vow<import("./cosmos-api.js").IcaAccount>;
+        provideICQConnection(controllerConnectionId: import("@agoric/vats").IBCConnectionID): import("@agoric/vow").Vow<import("./types.js").ICQConnection> | import("./types.js").ICQConnection;
     }>;
 } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
     /** @param {Partial<OrchestrationPowers>} [initialPowers] */
-    makeOrchestrationKit(initialPowers?: Partial<OrchestrationPowers> | undefined): import("@endo/exo").GuardedKit<{
-        requestICAChannelWatcher: {
-            onFulfilled(port: import("@agoric/network").Port, { chainId, remoteConnAddr }: {
-                chainId: string;
-                remoteConnAddr: import("@agoric/vats/tools/ibc-utils.js").RemoteIbcAddress;
-            }): import("@agoric/vow").Vow<any>;
-        };
-        requestICQChannelWatcher: {
-            onFulfilled(port: import("@agoric/network").Port, { remoteConnAddr, controllerConnectionId }: {
-                remoteConnAddr: import("@agoric/vats/tools/ibc-utils.js").RemoteIbcAddress;
-                controllerConnectionId: import("@agoric/vats").IBCConnectionID;
-            }): import("@agoric/vow").Vow<any>;
-        };
-        channelOpenWatcher: {
-            onFulfilled(_connection: import("@agoric/network").Connection, { connectionKit, returnFacet, saveICQConnection }: {
-                connectionKit: ConnectionKit;
-                returnFacet: string;
-                saveICQConnection?: import("@agoric/vats").IBCConnectionID;
-            }): any;
-        };
-        public: {
-            makeAccount(chainId: string, hostConnectionId: import("@agoric/vats").IBCConnectionID, controllerConnectionId: import("@agoric/vats").IBCConnectionID): import("@agoric/vow").Vow<import("./cosmos-api.js").IcaAccount>;
-            provideICQConnection(controllerConnectionId: import("@agoric/vats").IBCConnectionID): import("@agoric/vow").Vow<import("./types.js").ICQConnection> | import("./types.js").ICQConnection;
-        };
+    makeCosmosInterchainService(initialPowers?: Partial<OrchestrationPowers> | undefined): import("@endo/exo").Guarded<{
+        makeAccount(chainId: string, hostConnectionId: import("@agoric/vats").IBCConnectionID, controllerConnectionId: import("@agoric/vats").IBCConnectionID): import("@agoric/vow").Vow<import("./cosmos-api.js").IcaAccount>;
+        provideICQConnection(controllerConnectionId: import("@agoric/vats").IBCConnectionID): import("@agoric/vow").Vow<import("./types.js").ICQConnection> | import("./types.js").ICQConnection;
     }>;
 }>;
 export type OrchestrationVat = ReturnType<typeof buildRootObject>;
-import type { OrchestrationPowers } from './service.js';
+import type { OrchestrationPowers } from './exos/cosmos-interchain-service.js';
 //# sourceMappingURL=vat-orchestration.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"vat-orchestration.d.ts","sourceRoot":"","sources":["vat-orchestration.js"],"names":[],"mappings":"AAOO;IASH,4DAA4D;;;;;;;;;;;;;;;;;;iCAQg2J,CAAC;;;;;;;;;IAR75J,4DAA4D;;;;;;;;;;;;;;;;;;iCAQg2J,CAAC;;;;;;;;GAHh6J;+BAEa,UAAU,CAAC,OAAO,eAAe,CAAC;yCAlBT,cAAc"}
+{"version":3,"file":"vat-orchestration.d.ts","sourceRoot":"","sources":["vat-orchestration.js"],"names":[],"mappings":"AAOO;IASH,4DAA4D;;;;;;IAA5D,4DAA4D;;;;;GAK/D;+BAEa,UAAU,CAAC,OAAO,eAAe,CAAC;yCAlBT,qCAAqC"}

package/src/vat-orchestration.js

@@ -1,22 +1,22 @@
 import { Far } from '@endo/far';
-import { prepareVowTools } from '@agoric/vow/vat.js';
+import { prepareSwingsetVowTools } from '@agoric/vow/vat.js';
 import { makeDurableZone } from '@agoric/zone/durable.js';
-import { prepareOrchestrationTools } from './service.js';
+import { prepareCosmosInterchainService } from './exos/cosmos-interchain-service.js';
 
-/** @import {OrchestrationPowers} from './service.js' */
+/** @import {OrchestrationPowers} from './exos/cosmos-interchain-service.js' */
 
 export const buildRootObject = (_vatPowers, _args, baggage) => {
   const zone = makeDurableZone(baggage);
-  const vowTools = prepareVowTools(zone.subZone('VowTools'));
-  const { makeOrchestrationKit } = prepareOrchestrationTools(
+  const vowTools = prepareSwingsetVowTools(zone.subZone('VowTools'));
+  const makeCosmosInterchainService = prepareCosmosInterchainService(
     zone.subZone('orchestration'),
     vowTools,
   );
 
   return Far('OrchestrationVat', {
     /** @param {Partial<OrchestrationPowers>} [initialPowers] */
-    makeOrchestrationKit(initialPowers = {}) {
-      return makeOrchestrationKit(initialPowers);
+    makeCosmosInterchainService(initialPowers = {}) {
+      return makeCosmosInterchainService(initialPowers);
     },
   });
 };

package/src/service.d.ts

@@ -1,97 +0,0 @@
-export function prepareOrchestrationTools(zone: Zone, vowTools: VowTools): {
-    makeOrchestrationKit: (initialPowers?: Partial<OrchestrationPowers> | undefined) => import("@endo/exo").GuardedKit<{
-        requestICAChannelWatcher: {
-            /**
-             * @param {Port} port
-             * @param {{
-             *   chainId: string;
-             *   remoteConnAddr: RemoteIbcAddress;
-             * }} watchContext
-             */
-            onFulfilled(port: Port, { chainId, remoteConnAddr }: {
-                chainId: string;
-                remoteConnAddr: RemoteIbcAddress;
-            }): Vow<any>;
-        };
-        requestICQChannelWatcher: {
-            /**
-             * @param {Port} port
-             * @param {{
-             *   remoteConnAddr: RemoteIbcAddress;
-             *   controllerConnectionId: IBCConnectionID;
-             * }} watchContext
-             */
-            onFulfilled(port: Port, { remoteConnAddr, controllerConnectionId }: {
-                remoteConnAddr: RemoteIbcAddress;
-                controllerConnectionId: IBCConnectionID;
-            }): Vow<any>;
-        };
-        /**
-         * Waits for a channel (ICA, ICQ) to open and returns the consumer-facing
-         * facet of the ConnectionKit, specified by `returnFacet`. Saves the
-         * ConnectionKit if `saveICQConnection` is provided.
-         */
-        channelOpenWatcher: {
-            /**
-             * @param {Connection} _connection
-             * @param {{
-             *   connectionKit: ConnectionKit;
-             *   returnFacet: string;
-             *   saveICQConnection?: IBCConnectionID;
-             * }} watchContext
-             */
-            onFulfilled(_connection: Connection, { connectionKit, returnFacet, saveICQConnection }: {
-                connectionKit: ConnectionKit;
-                returnFacet: string;
-                saveICQConnection?: IBCConnectionID;
-            }): any;
-        };
-        public: {
-            /**
-             * @param {string} chainId
-             * @param {IBCConnectionID} hostConnectionId the counterparty
-             *   connection_id
-             * @param {IBCConnectionID} controllerConnectionId self connection_id
-             * @returns {Vow<IcaAccount>}
-             */
-            makeAccount(chainId: string, hostConnectionId: IBCConnectionID, controllerConnectionId: IBCConnectionID): Vow<IcaAccount>;
-            /**
-             * @param {IBCConnectionID} controllerConnectionId
-             * @returns {Vow<ICQConnection> | ICQConnection}
-             */
-            provideICQConnection(controllerConnectionId: IBCConnectionID): Vow<ICQConnection> | ICQConnection;
-        };
-    }>;
-};
-export type OrchestrationPowers = {
-    portAllocator: Remote<PortAllocator>;
-};
-/**
- * PowerStore is used so additional powers can be added on upgrade. See
- * [#7337](https://github.com/Agoric/agoric-sdk/issues/7337) for tracking on Exo
- * state migrations.
- */
-export type PowerStore = MapStore<keyof OrchestrationPowers, OrchestrationPowers[keyof OrchestrationPowers]>;
-export type ICQConnectionStore = MapStore<IBCConnectionID, ICQConnectionKit>;
-export type ConnectionKit = ChainAccountKit | ICQConnectionKit;
-export type OrchestrationState = {
-    powers: PowerStore;
-    icqConnections: ICQConnectionStore;
-};
-export type OrchestrationTools = ReturnType<typeof prepareOrchestrationTools>;
-export type OrchestrationKit = ReturnType<OrchestrationTools["makeOrchestrationKit"]>;
-export type OrchestrationService = OrchestrationKit["public"];
-import type { Zone } from '@agoric/base-zone';
-import type { VowTools } from '@agoric/vow';
-import type { Port } from '@agoric/network';
-import type { RemoteIbcAddress } from '@agoric/vats/tools/ibc-utils.js';
-import type { Vow } from '@agoric/vow';
-import type { IBCConnectionID } from '@agoric/vats';
-import type { Connection } from '@agoric/network';
-import type { IcaAccount } from './types.js';
-import type { ICQConnection } from './types.js';
-import type { PortAllocator } from '@agoric/network';
-import type { Remote } from '@agoric/internal';
-import type { ICQConnectionKit } from './types.js';
-import type { ChainAccountKit } from './types.js';
-//# sourceMappingURL=service.d.ts.map

package/src/service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["service.js"],"names":[],"mappings":"AAkPO,gDAHI,IAAI,YACJ,QAAQ;;;YA3HX;;;;;;eAMG;8BALQ,IAAI,+BACJ;gBACV,OAAW,EAAE,MAAM,CAAC;gBACpB,cAAkB,EAAE,gBAAgB,CAAC;aAClC;;;YAgBJ;;;;;;eAMG;8BALQ,IAAI,8CACJ;gBACV,cAAkB,EAAE,gBAAgB,CAAC;gBACrC,sBAA0B,EAAE,eAAe,CAAC;aACzC;;QAgBN;;;;WAIG;;YAED;;;;;;;eAOG;qCANQ,UAAU,qDACV;gBACV,aAAiB,EAAE,aAAa,CAAC;gBACjC,WAAe,EAAE,MAAM,CAAC;gBACxB,iBAAqB,CAAC,EAAE,eAAe,CAAC;aACrC;;;YAkBJ;;;;;;eAMG;iCALQ,MAAM,oBACN,eAAe,0BAEf,eAAe,GACb,IAAI,UAAU,CAAC;YAiB5B;;;eAGG;yDAFQ,eAAe,GACb,IAAI,aAAa,CAAC,GAAG,aAAa;;;EAwCtD;;mBAnOa,OAAO,aAAa,CAAC;;;;;;;yBAQtB,QAAQ,CACpB,MAAU,mBAAmB,EAC7B,mBAAuB,CAAC,MAAM,mBAAmB,CAAC,CAC/C;iCAGU,QAAQ,CAAC,eAAe,EAAE,gBAAgB,CAAC;4BAE3C,eAAe,GAAG,gBAAgB;iCAYlC;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,cAAc,EAAE,kBAAkB,CAAA;CAAE;iCA0M1D,UAAU,CAAC,OAAO,yBAAyB,CAAC;+BAC5C,UAAU,CAAC,kBAAkB,CAAC,sBAAsB,CAAC,CAAC;mCACtD,gBAAgB,CAAC,QAAQ,CAAC;0BApPjB,mBAAmB;8BAKV,aAAa;0BAHK,iBAAiB;sCAEhC,iCAAiC;yBACpC,aAAa;qCAFX,cAAc;gCADE,iBAAiB;gCAIY,YAAY;mCAAZ,YAAY;mCAJzC,iBAAiB;4BAD1C,kBAAkB;sCAKoC,YAAY;qCAAZ,YAAY"}