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

package/src/exos/chain-hub.js

@@ -3,18 +3,12 @@ import { E } from '@endo/far';
 import { M } from '@endo/patterns';
 
 import { VowShape } from '@agoric/vow';
-// eslint-disable-next-line no-restricted-syntax
-import { heapVowTools } from '@agoric/vow/vat.js';
 import { makeHeapZone } from '@agoric/zone';
 import { CosmosChainInfoShape, IBCConnectionInfoShape } from '../typeGuards.js';
 
-// FIXME test thoroughly whether heap suffices for ChainHub
-// eslint-disable-next-line no-restricted-syntax
-const { allVows, watch } = heapVowTools;
-
 /**
  * @import {NameHub} from '@agoric/vats';
- * @import {Vow} from '@agoric/vow';
+ * @import {Vow, VowTools} from '@agoric/vow';
  * @import {CosmosChainInfo, IBCConnectionInfo} from '../cosmos-api.js';
  * @import {ChainInfo, KnownChains} from '../chain-info.js';
  * @import {Remote} from '@agoric/internal';
@@ -94,9 +88,10 @@ const ChainHubI = M.interface('ChainHub', {
  * hub and repeat the registrations.
  *
  * @param {Remote<NameHub>} agoricNames
- * @param {Zone} [zone]
+ * @param {VowTools} vowTools
  */
-export const makeChainHub = (agoricNames, zone = makeHeapZone()) => {
+export const makeChainHub = (agoricNames, vowTools) => {
+  const zone = makeHeapZone();
   /** @type {MapStore<string, CosmosChainInfo>} */
   const chainInfos = zone.mapStore('chainInfos', {
     keyShape: M.string(),
@@ -108,6 +103,89 @@ export const makeChainHub = (agoricNames, zone = makeHeapZone()) => {
     valueShape: IBCConnectionInfoShape,
   });
 
+  const lookupChainInfo = vowTools.retriable(
+    zone,
+    'lookupChainInfo',
+    /** @param {string} chainName */
+    // eslint-disable-next-line no-restricted-syntax -- TODO more exact rules for vow best practices
+    async chainName => {
+      await null;
+      try {
+        const chainInfo = await E(agoricNames).lookup(CHAIN_KEY, chainName);
+        // It may have been set by another concurrent call
+        // TODO consider makeAtomicProvider for vows
+        if (!chainInfos.has(chainName)) {
+          chainInfos.init(chainName, chainInfo);
+        }
+        return chainInfo;
+      } catch (e) {
+        console.error('lookupChainInfo', chainName, 'error', e);
+        throw makeError(`chain not found:${chainName}`);
+      }
+    },
+  );
+
+  const lookupConnectionInfo = vowTools.retriable(
+    zone,
+    'lookupConnectionInfo',
+    /**
+     * @param {string} chainId1
+     * @param {string} chainId2
+     */
+    // eslint-disable-next-line no-restricted-syntax -- TODO more exact rules for vow best practices
+    async (chainId1, chainId2) => {
+      await null;
+      const key = connectionKey(chainId1, chainId2);
+      try {
+        const connectionInfo = await E(agoricNames).lookup(
+          CONNECTIONS_KEY,
+          key,
+        );
+        // It may have been set by another concurrent call
+        // TODO consider makeAtomicProvider for vows
+        if (!connectionInfos.has(key)) {
+          connectionInfos.init(key, connectionInfo);
+        }
+        return connectionInfo;
+      } catch (e) {
+        console.error('lookupConnectionInfo', chainId1, chainId2, 'error', e);
+        throw makeError(`connection not found: ${chainId1}<->${chainId2}`);
+      }
+    },
+  );
+
+  /* eslint-disable no-use-before-define -- chainHub defined below */
+  const lookupChainsAndConnection = vowTools.retriable(
+    zone,
+    'lookupChainsAndConnection',
+    /**
+     * @template {string} C1
+     * @template {string} C2
+     * @param {C1} chainName1
+     * @param {C2} chainName2
+     * @returns {Promise<
+     *   [ActualChainInfo<C1>, ActualChainInfo<C2>, IBCConnectionInfo]
+     * >}
+     */
+    // eslint-disable-next-line no-restricted-syntax -- TODO more exact rules for vow best practices
+    async (chainName1, chainName2) => {
+      const [chain1, chain2] = await vowTools.asPromise(
+        vowTools.allVows([
+          chainHub.getChainInfo(chainName1),
+          chainHub.getChainInfo(chainName2),
+        ]),
+      );
+      const connectionInfo = await vowTools.asPromise(
+        chainHub.getConnectionInfo(chain2, chain1),
+      );
+      return /** @type {[ActualChainInfo<C1>, ActualChainInfo<C2>, IBCConnectionInfo]} */ ([
+        chain1,
+        chain2,
+        connectionInfo,
+      ]);
+    },
+  );
+
   const chainHub = zone.exo('ChainHub', ChainHubI, {
     /**
      * Register a new chain. The name will override a name in well known chain
@@ -133,19 +211,11 @@ export const makeChainHub = (agoricNames, zone = makeHeapZone()) => {
       // Either from registerChain or memoized remote lookup()
       if (chainInfos.has(chainName)) {
         return /** @type {Vow<ActualChainInfo<K>>} */ (
-          watch(chainInfos.get(chainName))
+          vowTools.asVow(() => chainInfos.get(chainName))
         );
       }
 
-      return watch(E(agoricNames).lookup(CHAIN_KEY, chainName), {
-        onFulfilled: chainInfo => {
-          chainInfos.init(chainName, chainInfo);
-          return chainInfo;
-        },
-        onRejected: _cause => {
-          throw makeError(`chain not found:${chainName}`);
-        },
-      });
+      return lookupChainInfo(chainName);
     },
     /**
      * @param {string} chainId1
@@ -167,18 +237,10 @@ export const makeChainHub = (agoricNames, zone = makeHeapZone()) => {
       const chainId2 = typeof chain2 === 'string' ? chain2 : chain2.chainId;
       const key = connectionKey(chainId1, chainId2);
       if (connectionInfos.has(key)) {
-        return watch(connectionInfos.get(key));
+        return vowTools.asVow(() => connectionInfos.get(key));
       }
 
-      return watch(E(agoricNames).lookup(CONNECTIONS_KEY, key), {
-        onFulfilled: connectionInfo => {
-          connectionInfos.init(key, connectionInfo);
-          return connectionInfo;
-        },
-        onRejected: _cause => {
-          throw makeError(`connection not found: ${chainId1}<->${chainId2}`);
-        },
-      });
+      return lookupConnectionInfo(chainId1, chainId2);
     },
 
     /**
@@ -191,21 +253,8 @@ export const makeChainHub = (agoricNames, zone = makeHeapZone()) => {
      * >}
      */
     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];
-              },
-            });
-          },
-        },
-      );
+      // @ts-expect-error XXX generic parameter propagation
+      return lookupChainsAndConnection(chainName1, chainName2);
     },
   });
 

package/src/exos/cosmos-interchain-service.d.ts

@@ -0,0 +1,43 @@
+export function prepareCosmosInterchainService(zone: Zone, vowTools: VowTools): (initialPowers: any) => import("@endo/exo").Guarded<{
+    /**
+     * @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 MakeCosmosInterchainService = ReturnType<typeof prepareCosmosInterchainService>;
+export type CosmosInterchainService = ReturnType<MakeCosmosInterchainService>;
+import type { Zone } from '@agoric/base-zone';
+import type { VowTools } from '@agoric/vow';
+import type { IBCConnectionID } from '@agoric/vats';
+import type { IcaAccount } from '../types.js';
+import type { Vow } from '@agoric/vow';
+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=cosmos-interchain-service.d.ts.map

package/src/exos/cosmos-interchain-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosmos-interchain-service.d.ts","sourceRoot":"","sources":["cosmos-interchain-service.js"],"names":[],"mappings":"AAkPO,qDAHI,IAAI,YACJ,QAAQ;IAnDX;;;;;;OAMG;yBALQ,MAAM,oBACN,eAAe,0BAEf,eAAe,GACb,IAAI,UAAU,CAAC;IAiB5B;;;OAGG;iDAFQ,eAAe,GACb,IAAI,aAAa,CAAC,GAAG,aAAa;GA4CtD;;mBAvOa,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;0CA8M1D,UAAU,CAAC,OAAO,8BAA8B,CAAC;sCACjD,UAAU,CAAC,2BAA2B,CAAC;0BAvP9B,mBAAmB;8BAKV,aAAa;qCAFX,cAAc;gCAG+B,aAAa;yBAD5D,aAAa;mCACkC,aAAa;mCAJ1C,iBAAiB;4BAD1C,kBAAkB;sCAKoC,aAAa;qCAAb,aAAa"}

package/src/{service.js → exos/cosmos-interchain-service.js}

@@ -4,12 +4,12 @@ import { Fail, b } from '@endo/errors';
 import { E } from '@endo/far';
 import { M } from '@endo/patterns';
 import { Shape as NetworkShape } from '@agoric/network';
-import { prepareChainAccountKit } from './exos/chain-account-kit.js';
-import { prepareICQConnectionKit } from './exos/icq-connection-kit.js';
+import { prepareChainAccountKit } from './chain-account-kit.js';
+import { prepareICQConnectionKit } from './icq-connection-kit.js';
 import {
   makeICAChannelAddress,
   makeICQChannelAddress,
-} from './utils/address.js';
+} from '../utils/address.js';
 
 /**
  * @import {Zone} from '@agoric/base-zone';
@@ -18,7 +18,7 @@ import {
  * @import {IBCConnectionID} from '@agoric/vats';
  * @import {RemoteIbcAddress} from '@agoric/vats/tools/ibc-utils.js';
  * @import {Vow, VowTools} from '@agoric/vow';
- * @import {ICQConnection, IcaAccount, ICQConnectionKit, ChainAccountKit} from './types.js';
+ * @import {ICQConnection, IcaAccount, ICQConnectionKit, ChainAccountKit} from '../types.js';
  */
 
 const { Vow$ } = NetworkShape; // TODO #9611
@@ -60,7 +60,7 @@ const getPower = (powers, name) => {
  * @param {ReturnType<typeof prepareChainAccountKit>} makeChainAccountKit
  * @param {ReturnType<typeof prepareICQConnectionKit>} makeICQConnectionKit
  */
-const prepareOrchestrationKit = (
+const prepareCosmosOrchestrationServiceKit = (
   zone,
   { watch },
   makeChainAccountKit,
@@ -92,7 +92,7 @@ const prepareOrchestrationKit = (
           )
           .returns(M.remotable('ConnectionKit Holder facet')),
       }),
-      public: M.interface('OrchestrationService', {
+      public: M.interface('CosmosInterchainService', {
         makeAccount: M.call(M.string(), M.string(), M.string()).returns(
           Vow$(M.remotable('ChainAccountKit')),
         ),
@@ -240,20 +240,23 @@ const prepareOrchestrationKit = (
  * @param {Zone} zone
  * @param {VowTools} vowTools
  */
-export const prepareOrchestrationTools = (zone, vowTools) => {
+export const prepareCosmosInterchainService = (zone, vowTools) => {
   const makeChainAccountKit = prepareChainAccountKit(zone, vowTools);
   const makeICQConnectionKit = prepareICQConnectionKit(zone, vowTools);
-  const makeOrchestrationKit = prepareOrchestrationKit(
-    zone,
-    vowTools,
-    makeChainAccountKit,
-    makeICQConnectionKit,
-  );
+  const makeCosmosOrchestrationServiceKit =
+    prepareCosmosOrchestrationServiceKit(
+      zone,
+      vowTools,
+      makeChainAccountKit,
+      makeICQConnectionKit,
+    );
+
+  const makeCosmosInterchainService = initialPowers =>
+    makeCosmosOrchestrationServiceKit(initialPowers).public;
 
-  return harden({ makeOrchestrationKit });
+  return makeCosmosInterchainService;
 };
-harden(prepareOrchestrationTools);
+harden(prepareCosmosInterchainService);
 
-/** @typedef {ReturnType<typeof prepareOrchestrationTools>} OrchestrationTools */
-/** @typedef {ReturnType<OrchestrationTools['makeOrchestrationKit']>} OrchestrationKit */
-/** @typedef {OrchestrationKit['public']} OrchestrationService */
+/** @typedef {ReturnType<typeof prepareCosmosInterchainService>} MakeCosmosInterchainService */
+/** @typedef {ReturnType<MakeCosmosInterchainService>} CosmosInterchainService */

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

@@ -57,7 +57,7 @@ export function prepareLocalChainFacade(zone: Zone, powers: LocalChainFacadePowe
 }>>["public"];
 export type LocalChainFacadePowers = {
     makeLocalOrchestrationAccountKit: MakeLocalOrchestrationAccountKit;
-    orchestration: Remote<OrchestrationService>;
+    orchestration: Remote<CosmosInterchainService>;
     storageNode: Remote<StorageNode>;
     timer: Remote<TimerService>;
     localchain: Remote<LocalChain>;
@@ -73,7 +73,7 @@ import type { PromiseToVow } from '../types.js';
 import type { LocalChainAccount } from '@agoric/vats/src/localchain.js';
 import type { ChainAddress } from '../types.js';
 import type { MakeLocalOrchestrationAccountKit } from './local-orchestration-account.js';
-import type { OrchestrationService } from '../service.js';
+import type { CosmosInterchainService } from './cosmos-interchain-service.js';
 import type { Remote } from '@agoric/internal';
 import type { TimerService } from '@agoric/time';
 import type { LocalChain } from '@agoric/vats/src/localchain.js';

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":"AA0GO,8CAHI,IAAI,UACJ,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;QAtCzB,oEAAoE;uBAAtD,IAAI,aAAa,qBAAqB,SAAS,CAAC,CAAC,CAAC;;;QAchE;;WAEG;wCADQ,CAAC,iBAAiB,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;cA4B5D;qCA1FY;IACZ,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;mCAsFU,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BAxGjC,mBAAmB;uCAOwE,aAAa;yBAH/F,aAAa;+BAGqE,aAAa;0CAAb,aAAa;kCAAb,aAAa;uCAJ/E,gCAAgC;kCAIkC,aAAa;sDAD5E,kCAAkC;0CAD9C,eAAe;4BAH7B,kBAAkB;kCADZ,cAAc;gCAEG,gCAAgC;8BAChD,aAAa"}
+{"version":3,"file":"local-chain-facade.d.ts","sourceRoot":"","sources":["local-chain-facade.js"],"names":[],"mappings":"AA0GO,8CAHI,IAAI,UACJ,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;QAtCzB,oEAAoE;uBAAtD,IAAI,aAAa,qBAAqB,SAAS,CAAC,CAAC,CAAC;;;QAchE;;WAEG;wCADQ,CAAC,iBAAiB,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;cA4B5D;qCA1FY;IACZ,gCAAoC,EAAE,gCAAgC,CAAC;IACvE,aAAiB,EAAE,OAAO,uBAAuB,CAAC,CAAC;IACnD,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;mCAsFU,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BAxGjC,mBAAmB;uCAOwE,aAAa;yBAH/F,aAAa;+BAGqE,aAAa;0CAAb,aAAa;kCAAb,aAAa;uCAJ/E,gCAAgC;kCAIkC,aAAa;sDAD5E,kCAAkC;6CAD3C,gCAAgC;4BAHjD,kBAAkB;kCADZ,cAAc;gCAEG,gCAAgC;8BAChD,aAAa"}

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

@@ -11,7 +11,7 @@ import { ChainFacadeI } from '../typeGuards.js';
  * @import {Remote} from '@agoric/internal';
  * @import {LocalChain, LocalChainAccount} from '@agoric/vats/src/localchain.js';
  * @import {Vow, VowTools} from '@agoric/vow';
- * @import {OrchestrationService} from '../service.js';
+ * @import {CosmosInterchainService} from './cosmos-interchain-service.js';
  * @import {MakeLocalOrchestrationAccountKit} from './local-orchestration-account.js';
  * @import {ChainAddress, ChainInfo, CosmosChainInfo, IBCConnectionInfo, OrchestrationAccount, PromiseToVow} from '../types.js';
  */
@@ -19,7 +19,7 @@ import { ChainFacadeI } from '../typeGuards.js';
 /**
  * @typedef {{
  *   makeLocalOrchestrationAccountKit: MakeLocalOrchestrationAccountKit;
- *   orchestration: Remote<OrchestrationService>;
+ *   orchestration: Remote<CosmosInterchainService>;
  *   storageNode: Remote<StorageNode>;
  *   timer: Remote<TimerService>;
  *   localchain: Remote<LocalChain>;

package/src/exos/orchestrator.d.ts

@@ -12,7 +12,7 @@ export function prepareOrchestratorKit(zone: Zone, { chainHub, localchain, makeL
     makeRecorderKit: MakeRecorderKit;
     makeLocalChainFacade: MakeLocalChainFacade;
     makeRemoteChainFacade: MakeRemoteChainFacade;
-    orchestrationService: Remote<OrchestrationService>;
+    orchestrationService: Remote<CosmosInterchainService>;
     storageNode: Remote<StorageNode>;
     timerService: Remote<TimerService>;
     vowTools: VowTools;
@@ -79,7 +79,7 @@ import type { Remote } from '@agoric/internal';
 import type { MakeRecorderKit } from '@agoric/zoe/src/contractSupport/recorder.js';
 import type { MakeLocalChainFacade } from './local-chain-facade.js';
 import type { MakeRemoteChainFacade } from './remote-chain-facade.js';
-import type { OrchestrationService } from '../service.js';
+import type { CosmosInterchainService } from './cosmos-interchain-service.js';
 import type { TimerService } from '@agoric/time';
 import type { VowTools } from '@agoric/vow';
 import type { ChainInfo } from '../types.js';

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

@@ -1 +1 @@
-{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["orchestrator.js"],"names":[],"mappings":"AAmCA,0BAA0B;AAC1B;;;;;GAKG;AAkBI,6CAfI,IAAI,+FACJ;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,qDAAqD;;;;;;;;;;;;;GAwB1D;0BA5HoB,mBAAmB;oCAET,oBAAoB;8BAD1B,gBAAgB;gCAId,gCAAgC;4BAEpC,kBAAkB;qCADI,6CAA6C;0CAKrD,yBAAyB;2CACxB,0BAA0B;0CAH3B,eAAe;kCALvB,cAAc;8BADb,aAAa;+BAU4E,aAAa;uCAAb,aAAa;yBAVtG,aAAa;0CAU4E,aAAa;kCAAb,aAAa;2BAAb,aAAa"}
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["orchestrator.js"],"names":[],"mappings":"AAmCA,0BAA0B;AAC1B;;;;;GAKG;AAkBI,6CAfI,IAAI,+FACJ;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,uBAAuB,CAAC,CAAC;IAC1D,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,qDAAqD;;;;;;;;;;;;;GAwB1D;0BA5HoB,mBAAmB;oCAET,oBAAoB;8BAD1B,gBAAgB;gCAId,gCAAgC;4BAEpC,kBAAkB;qCADI,6CAA6C;0CAKrD,yBAAyB;2CACxB,0BAA0B;6CAHxB,gCAAgC;kCAL3C,cAAc;8BADb,aAAa;+BAU4E,aAAa;uCAAb,aAAa;yBAVtG,aAAa;0CAU4E,aAAa;kCAAb,aAAa;2BAAb,aAAa"}

package/src/exos/orchestrator.js

@@ -22,7 +22,7 @@ import {
  * @import {RecorderKit, MakeRecorderKit} from '@agoric/zoe/src/contractSupport/recorder.js'.
  * @import {Remote} from '@agoric/internal';
  * @import {PickFacet} from '@agoric/swingset-liveslots';
- * @import {OrchestrationService} from '../service.js';
+ * @import {CosmosInterchainService} from './cosmos-interchain-service.js';
  * @import {MakeLocalOrchestrationAccountKit} from './local-orchestration-account.js';
  * @import {MakeLocalChainFacade} from './local-chain-facade.js';
  * @import {MakeRemoteChainFacade} from './remote-chain-facade.js';
@@ -50,7 +50,7 @@ export const OrchestratorI = M.interface('Orchestrator', {
  *   makeRecorderKit: MakeRecorderKit;
  *   makeLocalChainFacade: MakeLocalChainFacade;
  *   makeRemoteChainFacade: MakeRemoteChainFacade;
- *   orchestrationService: Remote<OrchestrationService>;
+ *   orchestrationService: Remote<CosmosInterchainService>;
  *   storageNode: Remote<StorageNode>;
  *   timerService: Remote<TimerService>;
  *   vowTools: VowTools;

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

@@ -119,7 +119,7 @@ export function prepareRemoteChainFacade(zone: Zone, powers: RemoteChainFacadePo
 }>>["public"];
 export type RemoteChainFacadePowers = {
     makeCosmosOrchestrationAccount: ReturnType<typeof prepareCosmosOrchestrationAccount>;
-    orchestration: Remote<OrchestrationService>;
+    orchestration: Remote<CosmosInterchainService>;
     storageNode: Remote<StorageNode>;
     timer: Remote<TimerService>;
     vowTools: VowTools;
@@ -135,7 +135,7 @@ import type { IcaAccount } from '../types.js';
 import type { Denom } from '../types.js';
 import type { ChainAddress } from '../types.js';
 import type { prepareCosmosOrchestrationAccount } from './cosmos-orchestration-account.js';
-import type { OrchestrationService } from '../service.js';
+import type { CosmosInterchainService } from './cosmos-interchain-service.js';
 import type { Remote } from '@agoric/internal';
 import type { TimerService } from '@agoric/time';
 import type { VowTools } from '@agoric/vow';

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":"AA0IO,+CAHI,IAAI,UACJ,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;QAzD1B,oEAAoE;uBAAtD,IAAI,aAAa,qBAAqB,SAAS,CAAC,CAAC,CAAC;;;QAwBhE;;;WAGG;6BAFQ,UAAU,gBACV,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAUhB;;;WAGG;kCAFQ,YAAY,6BACZ;YAAE,YAAY,EAAE,KAAK,CAAC;YAAC,OAAO,EAAE,UAAU,CAAA;SAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwB9D;sCApHY;IACZ,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;oCA+GU,UAAU,CAAC,OAAO,wBAAwB,CAAC;0BAvIlC,mBAAmB;uCAM2F,aAAa;yBAHlH,aAAa;+BAGwF,aAAa;0CAAb,aAAa;kCAAb,aAAa;gCAAb,aAAa;2BAAb,aAAa;kCAAb,aAAa;uDAD9F,mCAAmC;0CADhD,eAAe;4BAF7B,kBAAkB;kCADZ,cAAc;8BAEb,aAAa"}
+{"version":3,"file":"remote-chain-facade.d.ts","sourceRoot":"","sources":["remote-chain-facade.js"],"names":[],"mappings":"AA0IO,+CAHI,IAAI,UACJ,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;QAzD1B,oEAAoE;uBAAtD,IAAI,aAAa,qBAAqB,SAAS,CAAC,CAAC,CAAC;;;QAwBhE;;;WAGG;6BAFQ,UAAU,gBACV,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAUhB;;;WAGG;kCAFQ,YAAY,6BACZ;YAAE,YAAY,EAAE,KAAK,CAAC;YAAC,OAAO,EAAE,UAAU,CAAA;SAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwB9D;sCApHY;IACZ,8BAAkC,EAAE,UAAU,CAC9C,wCAA8C,CACzC,CAAC;IACN,aAAiB,EAAE,OAAO,uBAAuB,CAAC,CAAC;IACnD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,KAAS,EAAE,OAAO,YAAY,CAAC,CAAC;IAChC,QAAY,EAAE,QAAQ,CAAC;CACpB;oCA+GU,UAAU,CAAC,OAAO,wBAAwB,CAAC;0BAvIlC,mBAAmB;uCAM2F,aAAa;yBAHlH,aAAa;+BAGwF,aAAa;0CAAb,aAAa;kCAAb,aAAa;gCAAb,aAAa;2BAAb,aAAa;kCAAb,aAAa;uDAD9F,mCAAmC;6CAD7C,gCAAgC;4BAFjD,kBAAkB;kCADZ,cAAc;8BAEb,aAAa"}

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

@@ -11,7 +11,7 @@ import { ChainFacadeI } from '../typeGuards.js';
  * @import {TimerService} from '@agoric/time';
  * @import {Remote} from '@agoric/internal';
  * @import {Vow, VowTools} from '@agoric/vow';
- * @import {OrchestrationService} from '../service.js';
+ * @import {CosmosInterchainService} from './cosmos-interchain-service.js';
  * @import {prepareCosmosOrchestrationAccount} from './cosmos-orchestration-account.js';
  * @import {ChainInfo, CosmosChainInfo, IBCConnectionInfo, OrchestrationAccount, ChainAddress, IcaAccount, PromiseToVow, Denom} from '../types.js';
  */
@@ -27,7 +27,7 @@ const anyVal = null;
  *   makeCosmosOrchestrationAccount: ReturnType<
  *     typeof prepareCosmosOrchestrationAccount
  *   >;
- *   orchestration: Remote<OrchestrationService>;
+ *   orchestration: Remote<CosmosInterchainService>;
  *   storageNode: Remote<StorageNode>;
  *   timer: Remote<TimerService>;
  *   vowTools: VowTools;

package/src/facade.d.ts

@@ -3,7 +3,7 @@ export function makeOrchestrationFacade({ zone, timerService, zcf, storageNode,
     timerService: Remote<TimerService>;
     zcf: ZCF;
     storageNode: Remote<StorageNode>;
-    orchestrationService: Remote<OrchestrationService>;
+    orchestrationService: Remote<CosmosInterchainService>;
     localchain: Remote<LocalChain>;
     chainHub: import("./exos/chain-hub.js").ChainHub;
     makeLocalOrchestrationAccountKit: MakeLocalOrchestrationAccountKit;
@@ -45,7 +45,7 @@ export type OrchestrationFacade = ReturnType<typeof makeOrchestrationFacade>;
 import type { Zone } from '@agoric/zone';
 import type { TimerService } from '@agoric/time';
 import type { Remote } from '@agoric/internal';
-import type { OrchestrationService } from './service.js';
+import type { CosmosInterchainService } from './exos/cosmos-interchain-service.js';
 import type { LocalChain } from '@agoric/vats/src/localchain.js';
 import type { MakeLocalOrchestrationAccountKit } from './exos/local-orchestration-account.js';
 import type { MakeRecorderKit } from '@agoric/zoe/src/contractSupport/recorder.js';

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;IAmDA;;;;;;;;;;;;;;;;;;;OAmBG;gBAlBU,WAAW,EACX,UAAU,EACV,YAAY,EACZ,WAAW,EACH,SAAS,SAAhB,GAAG,EAAG,EACC,QAAQ,SAAf,GAAG,EAAG,eACT,MAAM,WAEN,WAAW,WAEX,CACV,QAAY,EAAE,YAAY,EAC1B,QAAY,EAAE,YAAY,EAC1B,GAAO,IAAI,EAAE,SAAS,KACf,OAAO,CAAC,WAAW,CAAC,GACf,CAAC,GAAG,IAAI,EAAE,QAAQ,KAAK,OAAO,CAAC,UAAU,CAAC;;;;;;EAwB1D;kCAEa,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BA3HjC,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,uBAAuB,CAAC,CAAC;IAC1D,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;IAmDA;;;;;;;;;;;;;;;;;;;OAmBG;gBAlBU,WAAW,EACX,UAAU,EACV,YAAY,EACZ,WAAW,EACH,SAAS,SAAhB,GAAG,EAAG,EACC,QAAQ,SAAf,GAAG,EAAG,eACT,MAAM,WAEN,WAAW,WAEX,CACV,QAAY,EAAE,YAAY,EAC1B,QAAY,EAAE,YAAY,EAC1B,GAAO,IAAI,EAAE,SAAS,KACf,OAAO,CAAC,WAAW,CAAC,GACf,CAAC,GAAG,IAAI,EAAE,QAAQ,KAAK,OAAO,CAAC,UAAU,CAAC;;;;;;EAwB1D;kCAEa,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BA3HjC,cAAc;kCAEN,cAAc;4BAIpB,kBAAkB;6CACD,qCAAqC;gCAHlD,gCAAgC;sDAOV,uCAAuC;qCAN3C,6CAA6C;0CAIrD,8BAA8B;2CAC7B,+BAA+B;8BATvC,aAAa;oCAFZ,oBAAoB;kCASsD,YAAY"}

package/src/facade.js

@@ -13,7 +13,7 @@ import { prepareOrchestratorKit } from './exos/orchestrator.js';
  * @import {LocalChain} from '@agoric/vats/src/localchain.js';
  * @import {RecorderKit, MakeRecorderKit} from '@agoric/zoe/src/contractSupport/recorder.js'.
  * @import {Remote} from '@agoric/internal';
- * @import {OrchestrationService} from './service.js';
+ * @import {CosmosInterchainService} from './exos/cosmos-interchain-service.js';
  * @import {Chain, ChainInfo, CosmosChainInfo, IBCConnectionInfo, OrchestrationAccount, Orchestrator} from './types.js';
  * @import {MakeLocalChainFacade} from './exos/local-chain-facade.js';
  * @import {MakeRemoteChainFacade} from './exos/remote-chain-facade.js';
@@ -26,7 +26,7 @@ import { prepareOrchestratorKit } from './exos/orchestrator.js';
  *   timerService: Remote<TimerService>;
  *   zcf: ZCF;
  *   storageNode: Remote<StorageNode>;
- *   orchestrationService: Remote<OrchestrationService>;
+ *   orchestrationService: Remote<CosmosInterchainService>;
  *   localchain: Remote<LocalChain>;
  *   chainHub: import('./exos/chain-hub.js').ChainHub;
  *   makeLocalOrchestrationAccountKit: MakeLocalOrchestrationAccountKit;

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

@@ -1,10 +1,8 @@
-export function setupOrchestrationVat({ consume: { loadCriticalVat, portAllocator: portAllocatorP }, produce: { orchestrationVat, orchestration, orchestrationKit: orchestrationKitP, }, }: BootstrapPowers & {
+export function setupOrchestrationVat({ consume: { loadCriticalVat, portAllocator: portAllocatorP }, produce: { orchestrationVat, ...produce }, }: BootstrapPowers & {
     consume: {
         portAllocator: PortAllocator;
     };
     produce: {
-        orchestration: Producer<any>;
-        orchestrationKit: Producer<any>;
         orchestrationVat: Producer<any>;
     };
 }, options: {
@@ -13,11 +11,6 @@ export function setupOrchestrationVat({ consume: { loadCriticalVat, portAllocato
     };
 }): Promise<void>;
 export function initChainInfo({ consume: { agoricNamesAdmin, chainStorage: chainStorageP }, }: BootstrapPowers): Promise<void>;
-export function addOrchestrationToClient({ consume: { client, orchestration } }: BootstrapPowers & {
-    consume: {
-        orchestration: OrchestrationService;
-    };
-}, _options: object): Promise<void>;
 export function getManifestForOrchestration(_powers: any, { orchestrationRef }: {
     orchestrationRef: any;
 }): {
@@ -30,8 +23,7 @@ export function getManifestForOrchestration(_powers: any, { orchestrationRef }:
                 chainStorage?: undefined;
             };
             produce: {
-                orchestration: string;
-                orchestrationKit: string;
+                cosmosInterchainService: string;
                 orchestrationVat: string;
             };
         } | {
@@ -49,5 +41,4 @@ export function getManifestForOrchestration(_powers: any, { orchestrationRef }:
     };
 };
 import type { PortAllocator } from '@agoric/network';
-import type { OrchestrationService } from '../service.js';
 //# sourceMappingURL=orchestration-proposal.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"orchestration-proposal.d.ts","sourceRoot":"","sources":["orchestration-proposal.js"],"names":[],"mappings":"AA4BO,4LAZI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,aAAmB,EAAE,aAAa,CAAC;KAC9B,CAAC;IACN,OAAW,EAAE;QACb,aAAmB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QACnC,gBAAsB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QACtC,gBAAsB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;KACjC,CAAC;CACH,WACO;IAAE,OAAO,EAAE;QAAE,gBAAgB,EAAE,YAAY,CAAA;KAAE,CAAA;CAAE,iBAiCzD;AAoEM,+FAFI,eAAe,iBAYzB;AAWM,iFAPI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,aAAmB,EAAE,oBAAoB,CAAC;KACrC,CAAC;CACH,YACO,MAAM,iBAOhB;AAEM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBL;mCAxK8B,iBAAiB;0CACV,eAAe"}
+{"version":3,"file":"orchestration-proposal.d.ts","sourceRoot":"","sources":["orchestration-proposal.js"],"names":[],"mappings":"AAyBO,mJAVI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,aAAmB,EAAE,aAAa,CAAC;KAC9B,CAAC;IACN,OAAW,EAAE;QACb,gBAAsB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;KACjC,CAAC;CACH,WACO;IAAE,OAAO,EAAE;QAAE,gBAAgB,EAAE,YAAY,CAAA;KAAE,CAAA;CAAE,iBA6BzD;AAoEM,+FAFI,eAAe,iBAYzB;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBL;mCAjJ8B,iBAAiB"}

package/src/proposals/orchestration-proposal.js

@@ -9,8 +9,7 @@ const trace = makeTracer('CoreEvalOrchestration', true);
 
 /**
  * @import {PortAllocator} from '@agoric/network';
- * @import {OrchestrationService} from '../service.js'
- * @import {OrchestrationVat} from '../vat-orchestration.js'
+ * @import {CosmosInterchainService} from '../exos/cosmos-interchain-service.js'
  */
 
 /**
@@ -19,8 +18,6 @@ const trace = makeTracer('CoreEvalOrchestration', true);
  *     portAllocator: PortAllocator;
  *   };
  *   produce: {
- *     orchestration: Producer<any>;
- *     orchestrationKit: Producer<any>;
  *     orchestrationVat: Producer<any>;
  *   };
  * }} powers
@@ -29,11 +26,7 @@ const trace = makeTracer('CoreEvalOrchestration', true);
 export const setupOrchestrationVat = async (
   {
     consume: { loadCriticalVat, portAllocator: portAllocatorP },
-    produce: {
-      orchestrationVat,
-      orchestration,
-      orchestrationKit: orchestrationKitP,
-    },
+    produce: { orchestrationVat, ...produce },
   },
   options,
 ) => {
@@ -49,14 +42,14 @@ export const setupOrchestrationVat = async (
 
   const portAllocator = await portAllocatorP;
 
-  const newOrchestrationKit = await E(vats.orchestration).makeOrchestrationKit({
+  const cosmosInterchainService = await E(
+    vats.orchestration,
+  ).makeCosmosInterchainService({
     portAllocator,
   });
 
-  orchestration.reset();
-  orchestration.resolve(newOrchestrationKit.public);
-  orchestrationKitP.reset();
-  orchestrationKitP.resolve(newOrchestrationKit);
+  produce.cosmosInterchainService.reset();
+  produce.cosmosInterchainService.resolve(cosmosInterchainService);
 };
 
 /**
@@ -138,21 +131,6 @@ export const initChainInfo = async ({
 };
 harden(initChainInfo);
 
-/**
- * @param {BootstrapPowers & {
- *   consume: {
- *     orchestration: OrchestrationService;
- *   };
- * }} powers
- * @param {object} _options
- */
-export const addOrchestrationToClient = async (
-  { consume: { client, orchestration } },
-  _options,
-) => {
-  return E(client).assignBundle([_a => ({ orchestration })]);
-};
-
 export const getManifestForOrchestration = (_powers, { orchestrationRef }) => ({
   manifest: {
     [setupOrchestrationVat.name]: {
@@ -161,8 +139,7 @@ export const getManifestForOrchestration = (_powers, { orchestrationRef }) => ({
         portAllocator: 'portAllocator',
       },
       produce: {
-        orchestration: 'orchestration',
-        orchestrationKit: 'orchestrationKit',
+        cosmosInterchainService: 'cosmosInterchainService',
         orchestrationVat: 'orchestrationVat',
       },
     },

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

@@ -1,8 +1,8 @@
-export function startStakeAtom({ consume: { agoricNames, board, chainStorage, chainTimerService, orchestration, startUpgradable, }, installation: { consume: { stakeIca }, }, instance: { produce: { stakeAtom: produceInstance }, }, }: BootstrapPowers & {
+export function startStakeAtom({ consume: { agoricNames, board, chainStorage, chainTimerService, cosmosInterchainService, startUpgradable, }, installation: { consume: { stakeIca }, }, instance: { produce: { stakeAtom: 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 getManifestForStakeAtom({ restoreRef }: {
                 board: boolean;
                 chainStorage: boolean;
                 chainTimerService: boolean;
-                orchestration: boolean;
+                cosmosInterchainService: boolean;
                 startUpgradable: boolean;
             };
             installation: {

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,iBAoDH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BN;mCAjG4C,+BAA+B"}
+{"version":3,"file":"start-stakeAtom.d.ts","sourceRoot":"","sources":["start-stakeAtom.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,iBAqDH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BN;mCAlG4C,+BAA+B"}