@agoric/orchestration 0.2.0-upgrade-17-dev-a1453b2.0 → 0.2.0-upgrade-18-dev-bf39b10.0

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

@@ -10,6 +10,7 @@ import { Fail, q } from '@endo/errors';
 
 import {
   AmountArgShape,
+  AnyNatAmountsRecord,
   ChainAddressShape,
   DenomAmountShape,
   DenomShape,
@@ -27,7 +28,7 @@ import { coerceCoin, coerceDenomAmount } from '../utils/amounts.js';
 /**
  * @import {HostOf} from '@agoric/async-flow';
  * @import {LocalChain, LocalChainAccount} from '@agoric/vats/src/localchain.js';
- * @import {AmountArg, ChainAddress, DenomAmount, IBCMsgTransferOptions, IBCConnectionInfo, OrchestrationAccountI} from '@agoric/orchestration';
+ * @import {AmountArg, ChainAddress, DenomAmount, IBCMsgTransferOptions, IBCConnectionInfo, OrchestrationAccountI, LocalAccountMethods} from '@agoric/orchestration';
  * @import {RecorderKit, MakeRecorderKit} from '@agoric/zoe/src/contractSupport/recorder.js'.
  * @import {Zone} from '@agoric/zone';
  * @import {Remote} from '@agoric/internal';
@@ -39,6 +40,7 @@ import { coerceCoin, coerceDenomAmount } from '../utils/amounts.js';
  * @import {Matcher} from '@endo/patterns';
  * @import {ChainHub} from './chain-hub.js';
  * @import {PacketTools} from './packet-tools.js';
+ * @import {ZoeTools} from '../utils/zoe-tools.js';
  */
 
 const trace = makeTracer('LOA');
@@ -91,10 +93,19 @@ const PUBLIC_TOPICS = {
  * @param {VowTools} powers.vowTools
  * @param {ChainHub} powers.chainHub
  * @param {Remote<LocalChain>} powers.localchain
+ * @param {ZoeTools} powers.zoeTools
  */
 export const prepareLocalOrchestrationAccountKit = (
   zone,
-  { makeRecorderKit, zcf, timerService, vowTools, chainHub, localchain },
+  {
+    makeRecorderKit,
+    zcf,
+    timerService,
+    vowTools,
+    chainHub,
+    localchain,
+    zoeTools,
+  },
 ) => {
   const { watch, allVows, asVow, when } = vowTools;
   const { makeIBCTransferSender } = prepareIBCTools(
@@ -139,6 +150,12 @@ export const prepareLocalOrchestrationAccountKit = (
       returnVoidWatcher: M.interface('returnVoidWatcher', {
         onFulfilled: M.call(M.any()).optional(M.any()).returns(M.undefined()),
       }),
+      seatExiterHandler: M.interface('seatExiterHandler', {
+        onFulfilled: M.call(M.undefined(), M.remotable()).returns(
+          M.undefined(),
+        ),
+        onRejected: M.call(M.error(), M.remotable()).returns(M.undefined()),
+      }),
       getBalanceWatcher: M.interface('getBalanceWatcher', {
         onFulfilled: M.call(AmountShape, DenomShape).returns(DenomAmountShape),
       }),
@@ -151,12 +168,14 @@ export const prepareLocalOrchestrationAccountKit = (
         ),
       }),
       invitationMakers: M.interface('invitationMakers', {
-        Delegate: M.call(M.string(), AmountShape).returns(M.promise()),
-        Undelegate: M.call(M.string(), AmountShape).returns(M.promise()),
         CloseAccount: M.call().returns(M.promise()),
+        Delegate: M.call(M.string(), AmountShape).returns(M.promise()),
+        Deposit: M.call().returns(M.promise()),
         Send: M.call().returns(M.promise()),
         SendAll: M.call().returns(M.promise()),
         Transfer: M.call().returns(M.promise()),
+        Undelegate: M.call(M.string(), AmountShape).returns(M.promise()),
+        Withdraw: M.call().returns(M.promise()),
       }),
     },
     /**
@@ -200,6 +219,27 @@ export const prepareLocalOrchestrationAccountKit = (
             );
           }, 'Delegate');
         },
+        Deposit() {
+          trace('Deposit');
+          return zcf.makeInvitation(
+            seat => {
+              const { give } = seat.getProposal();
+              return watch(
+                zoeTools.localTransfer(
+                  seat,
+                  // @ts-expect-error LocalAccount vs LocalAccountMethods
+                  this.state.account,
+                  give,
+                ),
+                this.facets.seatExiterHandler,
+                seat,
+              );
+            },
+            'Deposit',
+            undefined,
+            M.splitRecord({ give: AnyNatAmountsRecord, want: {} }),
+          );
+        },
         /**
          * @param {string} validatorAddress
          * @param {Amount<'nat'>} ertpAmount
@@ -250,18 +290,39 @@ export const prepareLocalOrchestrationAccountKit = (
            *   {
            *     amount: AmountArg;
            *     destination: ChainAddress;
-           *     opts: IBCMsgTransferOptions;
+           *     opts?: IBCMsgTransferOptions;
            *   }
            * >}
            */
           const offerHandler = (seat, { amount, destination, opts }) => {
             seat.exit();
             return watch(
-              this.facets.holder.transfer(amount, destination, opts),
+              this.facets.holder.transfer(destination, amount, opts),
             );
           };
           return zcf.makeInvitation(offerHandler, 'Transfer');
         },
+        Withdraw() {
+          trace('Withdraw');
+          return zcf.makeInvitation(
+            seat => {
+              const { want } = seat.getProposal();
+              return watch(
+                zoeTools.withdrawToSeat(
+                  // @ts-expect-error LocalAccount vs LocalAccountMethods
+                  this.state.account,
+                  seat,
+                  want,
+                ),
+                this.facets.seatExiterHandler,
+                seat,
+              );
+            },
+            'Withdraw',
+            undefined,
+            M.splitRecord({ give: {}, want: AnyNatAmountsRecord }),
+          );
+        },
       },
       undelegateWatcher: {
         /**
@@ -362,6 +423,24 @@ export const prepareLocalOrchestrationAccountKit = (
           return harden({ denom, value: natAmount.value });
         },
       },
+      /** exits or fails a seat depending the outcome */
+      seatExiterHandler: {
+        /**
+         * @param {undefined} _
+         * @param {ZCFSeat} seat
+         */
+        onFulfilled(_, seat) {
+          seat.exit();
+        },
+        /**
+         * @param {Error} reason
+         * @param {ZCFSeat} seat
+         */
+        onRejected(reason, seat) {
+          seat.exit(reason);
+          throw reason;
+        },
+      },
       /**
        * handles a QueryBalanceRequest from localchain.query and returns the
        * balance as a DenomAmount
@@ -387,8 +466,10 @@ export const prepareLocalOrchestrationAccountKit = (
        */
       queryBalancesWatcher: {
         /**
-         * @param {ResponseTo<
-         *   TypedJson<'/cosmos.bank.v1beta1.QueryAllBalancesRequest'>
+         * @param {JsonSafe<
+         *   ResponseTo<
+         *     TypedJson<'/cosmos.bank.v1beta1.QueryAllBalancesRequest'>
+         *   >
          * >} result
          * @returns {DenomAmount[]}
          */
@@ -532,14 +613,14 @@ export const prepareLocalOrchestrationAccountKit = (
          * updater will get a special notification that the account is being
          * transferred.
          */
-        /** @type {HostOf<LocalChainAccount['deposit']>} */
+        /** @type {HostOf<LocalAccountMethods['deposit']>} */
         deposit(payment) {
           return watch(
             E(this.state.account).deposit(payment),
             this.facets.returnVoidWatcher,
           );
         },
-        /** @type {HostOf<LocalChainAccount['withdraw']>} */
+        /** @type {HostOf<LocalAccountMethods['withdraw']>} */
         withdraw(amount) {
           return watch(E(this.state.account).withdraw(amount));
         },
@@ -594,15 +675,15 @@ export const prepareLocalOrchestrationAccountKit = (
           });
         },
         /**
+         * @param {ChainAddress} destination
          * @param {AmountArg} amount an ERTP {@link Amount} or a
          *   {@link DenomAmount}
-         * @param {ChainAddress} destination
          * @param {IBCMsgTransferOptions} [opts] if either timeoutHeight or
          *   timeoutTimestamp are not supplied, a default timeoutTimestamp will
          *   be set for 5 minutes in the future
          * @returns {Vow<any>}
          */
-        transfer(amount, destination, opts) {
+        transfer(destination, amount, opts) {
           return asVow(() => {
             trace('Transferring funds from LCA over IBC');
 
@@ -652,7 +733,7 @@ export const prepareLocalOrchestrationAccountKit = (
         matchFirstPacket(patternV) {
           return watch(E(this.state.packetTools).matchFirstPacket(patternV));
         },
-        /** @type {HostOf<LocalChainAccount['monitorTransfers']>} */
+        /** @type {HostOf<LocalAccountMethods['monitorTransfers']>} */
         monitorTransfers(tap) {
           return watch(E(this.state.packetTools).monitorTransfers(tap));
         },

package/src/exos/orchestrator.d.ts

@@ -1,149 +1,51 @@
 /** @see {Orchestrator} */
 export const OrchestratorI: import("@endo/patterns").InterfaceGuard<{
     getChain: import("@endo/patterns").MethodGuard;
-    makeLocalAccount: import("@endo/patterns").MethodGuard;
     getDenomInfo: import("@endo/patterns").MethodGuard;
     asAmount: import("@endo/patterns").MethodGuard;
 }>;
 export function prepareOrchestrator(zone: Zone, powers: {
-    asyncFlowTools: AsyncFlowTools;
     chainHub: ChainHub;
-    localchain: Remote<LocalChain>;
-    chainByName: MapStore<string, HostInterface<Chain<any>>>;
-    makeRecorderKit: MakeRecorderKit;
     makeLocalChainFacade: MakeLocalChainFacade;
     makeRemoteChainFacade: MakeRemoteChainFacade;
-    orchestrationService: Remote<CosmosInterchainService>;
-    storageNode: Remote<StorageNode>;
-    timerService: Remote<TimerService>;
     vowTools: VowTools;
-    zcf: ZCF;
-}): () => ReturnType<() => import("@endo/exo").GuardedKit<{
-    /** Waits for `chainInfo` and returns a LocalChainFacade */
-    makeLocalChainFacadeWatcher: {
-        /**
-         * @param {ActualChainInfo<'agoric'>} agoricChainInfo
-         */
-        onFulfilled(agoricChainInfo: ActualChainInfo<"agoric">): import("@endo/exo").Guarded<{
-            getChainInfo(): Vow<Readonly<{
-                chainId: string;
-                connections?: Record<string, IBCConnectionInfo>;
-                icqEnabled?: boolean;
-                stakingTokens?: Readonly<Array<{
-                    denom: string;
-                }>>;
-            }>>;
-            makeAccount(): Vow<import("./local-orchestration-account.js").LocalOrchestrationAccountKit["holder"]>;
-            query(args_0: {
-                '@type': string;
-            }[]): Vow<import("@agoric/cosmic-proto").JsonSafe<{
-                error?: string;
-                reply: {
-                    '@type': string;
-                };
-            }>[] extends import("@endo/pass-style").Passable ? import("@agoric/cosmic-proto").JsonSafe<{
-                error?: string;
-                reply: {
-                    '@type': string;
-                };
-            }>[] : HostInterface<import("@agoric/cosmic-proto").JsonSafe<{
-                error?: string;
-                reply: {
-                    '@type': string;
-                };
-            }>[]>>;
-            getVBankAssetInfo(): Vow<import("@agoric/vats/src/vat-bank.js").AssetInfo[] extends import("@endo/pass-style").Passable ? import("@agoric/vats/src/vat-bank.js").AssetInfo[] : HostInterface<import("@agoric/vats/src/vat-bank.js").AssetInfo[]>>;
-        }>;
-    };
-    /**
-     * Waits for `chainInfo` for `agoric` and a remote chain and returns a
-     * RemoteChainFacade
-     */
-    makeRemoteChainFacadeWatcher: {
-        /**
-         * Waits for `chainInfo` for `agoric` and a remote chain and returns a
-         * RemoteChainFacade
-         *
-         * @param {[ChainInfo, ChainInfo, IBCConnectionInfo]} chainsAndConnection
-         * @param {string} name
-         */
-        onFulfilled([_agoricChainInfo, remoteChainInfo, connectionInfo]: [ChainInfo, ChainInfo, IBCConnectionInfo], name: string): import("@endo/exo").Guarded<{
-            getChainInfo(): Vow<any extends import("@endo/pass-style").Passable ? any : HostInterface<any>>;
-            makeAccount(): Vow<import("../orchestration-api.js").OrchestrationAccount<any> extends import("@endo/pass-style").Passable ? import("@endo/pass-style").Passable & import("../orchestration-api.js").OrchestrationAccount<any> : HostInterface<import("../orchestration-api.js").OrchestrationAccount<any>>>;
-            query(msgs: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").RequestQuery>[]): Vow<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").ResponseQuery>[] extends import("@endo/pass-style").Passable ? import("@endo/pass-style").Passable & import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").ResponseQuery>[] : HostInterface<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").ResponseQuery>[]>>;
-        }>;
-    };
-    orchestrator: {
-        /** @type {HostOf<Orchestrator['getChain']>} */
-        getChain(chainName: string): Vow<Chain<any> extends import("@endo/pass-style").Passable ? import("@endo/pass-style").Passable & Chain<any> : HostInterface<Chain<any>>>;
-        makeLocalAccount(): Vow<import("@endo/exo").Guarded<{
-            getAddress(): string;
-            getBalance(brand: Brand<"nat">): import("@agoric/vow").PromiseVow<Amount<"nat">>;
-            deposit(payment: ERef<Payment<"nat">>, optAmountShape?: Pattern): import("@agoric/vow").PromiseVow<Amount<"nat">>;
-            withdraw(amount: Amount<"nat">): import("@agoric/vow").PromiseVow<Payment<"nat">>;
-            executeTx<MT extends import("@agoric/cosmic-proto").TypedJson[]>(messages: MT): PromiseVowOfTupleMappedToGenerics<{ [K in keyof MT]: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<MT[K]>>; }>;
-            monitorTransfers(tap: import("@agoric/vats/src/bridge-target.js").TargetApp): import("@agoric/vow").PromiseVow<import("@agoric/vats/src/bridge-target.js").TargetRegistration>;
-        }>>;
-        /** @type {HostOf<Orchestrator['getDenomInfo']>} */
-        getDenomInfo(denom: string): HostInterface<import("../orchestration-api.js").DenomInfo<"agoric" | "celestia" | "agoriclocal" | "cosmoshub" | "dydx" | "juno" | "neutron" | "noble" | "omniflixhub" | "osmosis" | "secretnetwork" | "stargaze" | "stride" | "umee", "agoric" | "celestia" | "agoriclocal" | "cosmoshub" | "dydx" | "juno" | "neutron" | "noble" | "omniflixhub" | "osmosis" | "secretnetwork" | "stargaze" | "stride" | "umee">>;
-        /** @type {HostOf<Orchestrator['asAmount']>} */
-        asAmount: HostOf<Orchestrator["asAmount"]>;
-    };
-}>>["orchestrator"];
+}): () => import("@endo/exo").Guarded<{
+    /** @type {HostOf<Orchestrator['getChain']>} */
+    getChain(chainName: string): Vow<HostInterface<Chain<any>>>;
+    /** @type {HostOf<Orchestrator['getDenomInfo']>} */
+    getDenomInfo(denom: string): HostInterface<import("../orchestration-api.js").DenomInfo<"agoric" | "celestia" | "cosmoshub" | "dydx" | "juno" | "neutron" | "noble" | "omniflixhub" | "osmosis" | "secretnetwork" | "stargaze" | "stride" | "umee", "agoric" | "celestia" | "cosmoshub" | "dydx" | "juno" | "neutron" | "noble" | "omniflixhub" | "osmosis" | "secretnetwork" | "stargaze" | "stride" | "umee">>;
+    /** @type {HostOf<Orchestrator['asAmount']>} */
+    asAmount: HostOf<Orchestrator["asAmount"]>;
+}>;
 /**
  * Host side of the Orchestrator interface. (Methods return vows instead of
  * promises as the interface within the guest function.)
  */
 export type HostOrchestrator = ReturnType<ReturnType<typeof prepareOrchestratorKit>>["orchestrator"];
 import type { Zone } from '@agoric/base-zone';
-import type { AsyncFlowTools } from '@agoric/async-flow';
 import type { ChainHub } from './chain-hub.js';
-import type { LocalChain } from '@agoric/vats/src/localchain.js';
-import type { Remote } from '@agoric/internal';
-import type { Chain } from '../types.js';
-import type { HostInterface } from '@agoric/async-flow';
-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 { CosmosInterchainService } from './exo-interfaces.js';
-import type { TimerService } from '@agoric/time';
 import type { VowTools } from '@agoric/vow';
-import type { ActualChainInfo } from './chain-hub.js';
-import type { IBCConnectionInfo } from '../types.js';
+import type { Chain } from '../types.js';
+import type { HostInterface } from '@agoric/async-flow';
 import type { Vow } from '@agoric/vow';
-import type { ChainInfo } from '../types.js';
 import type { Orchestrator } from '../types.js';
 import type { HostOf } from '@agoric/async-flow';
 /**
  * @param {Zone} zone
  * @param {{
- *   asyncFlowTools: AsyncFlowTools;
  *   chainHub: ChainHub;
- *   localchain: Remote<LocalChain>;
- *   chainByName: MapStore<string, HostInterface<Chain>>;
- *   makeRecorderKit: MakeRecorderKit;
  *   makeLocalChainFacade: MakeLocalChainFacade;
  *   makeRemoteChainFacade: MakeRemoteChainFacade;
- *   orchestrationService: Remote<CosmosInterchainService>;
- *   storageNode: Remote<StorageNode>;
- *   timerService: Remote<TimerService>;
  *   vowTools: VowTools;
- *   zcf: ZCF;
  * }} powers
  */
-declare function prepareOrchestratorKit(zone: Zone, { chainHub, localchain, chainByName, makeLocalChainFacade, makeRemoteChainFacade, vowTools: { watch, asVow }, }: {
-    asyncFlowTools: AsyncFlowTools;
+declare function prepareOrchestratorKit(zone: Zone, { chainHub, makeLocalChainFacade, makeRemoteChainFacade, vowTools: { watch, asVow }, }: {
     chainHub: ChainHub;
-    localchain: Remote<LocalChain>;
-    chainByName: MapStore<string, HostInterface<Chain<any>>>;
-    makeRecorderKit: MakeRecorderKit;
     makeLocalChainFacade: MakeLocalChainFacade;
     makeRemoteChainFacade: MakeRemoteChainFacade;
-    orchestrationService: Remote<CosmosInterchainService>;
-    storageNode: Remote<StorageNode>;
-    timerService: Remote<TimerService>;
     vowTools: VowTools;
-    zcf: ZCF;
 }): () => import("@endo/exo").GuardedKit<{
     /** Waits for `chainInfo` and returns a LocalChainFacade */
     makeLocalChainFacadeWatcher: {
@@ -162,23 +64,13 @@ declare function prepareOrchestratorKit(zone: Zone, { chainHub, localchain, chai
             makeAccount(): Vow<import("./local-orchestration-account.js").LocalOrchestrationAccountKit["holder"]>;
             query(args_0: {
                 '@type': string;
-            }[]): Vow<import("@agoric/cosmic-proto").JsonSafe<{
-                error?: string;
-                reply: {
-                    '@type': string;
-                };
-            }>[] extends import("@endo/pass-style").Passable ? import("@agoric/cosmic-proto").JsonSafe<{
-                error?: string;
-                reply: {
-                    '@type': string;
-                };
-            }>[] : HostInterface<import("@agoric/cosmic-proto").JsonSafe<{
-                error?: string;
+            }[]): Vow<{
+                error?: string | undefined;
                 reply: {
                     '@type': string;
                 };
-            }>[]>>;
-            getVBankAssetInfo(): Vow<import("@agoric/vats/src/vat-bank.js").AssetInfo[] extends import("@endo/pass-style").Passable ? import("@agoric/vats/src/vat-bank.js").AssetInfo[] : HostInterface<import("@agoric/vats/src/vat-bank.js").AssetInfo[]>>;
+            }[]>;
+            getVBankAssetInfo(): Vow<import("@agoric/vats/src/vat-bank.js").AssetInfo[]>;
         }>;
     };
     /**
@@ -194,27 +86,43 @@ declare function prepareOrchestratorKit(zone: Zone, { chainHub, localchain, chai
          * @param {string} name
          */
         onFulfilled([_agoricChainInfo, remoteChainInfo, connectionInfo]: [ChainInfo, ChainInfo, IBCConnectionInfo], name: string): import("@endo/exo").Guarded<{
-            getChainInfo(): Vow<any extends import("@endo/pass-style").Passable ? any : HostInterface<any>>;
-            makeAccount(): Vow<import("../orchestration-api.js").OrchestrationAccount<any> extends import("@endo/pass-style").Passable ? import("@endo/pass-style").Passable & import("../orchestration-api.js").OrchestrationAccount<any> : HostInterface<import("../orchestration-api.js").OrchestrationAccount<any>>>;
-            query(msgs: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").RequestQuery>[]): Vow<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").ResponseQuery>[] extends import("@endo/pass-style").Passable ? import("@endo/pass-style").Passable & import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").ResponseQuery>[] : HostInterface<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").ResponseQuery>[]>>;
+            getChainInfo(): Vow<any>;
+            makeAccount(): Vow<HostInterface<import("../orchestration-api.js").OrchestrationAccountI> | HostInterface<import("../orchestration-api.js").OrchestrationAccountI & import("../cosmos-api.js").LocalAccountMethods> | HostInterface<import("../orchestration-api.js").OrchestrationAccountI & import("../cosmos-api.js").StakingAccountActions & import("../cosmos-api.js").StakingAccountQueries> | HostInterface<import("../orchestration-api.js").OrchestrationAccountI & import("../cosmos-api.js").StakingAccountActions & import("../cosmos-api.js").StakingAccountQueries & import("../cosmos-api.js").LocalAccountMethods>>;
+            query(msgs: {
+                data: string;
+                path: string;
+                height: string;
+                prove: boolean;
+            }[]): Vow<{
+                code: number;
+                log: string;
+                info: string;
+                index: string;
+                key: string;
+                value: string;
+                proofOps?: {
+                    ops: {
+                        type: string;
+                        key: string;
+                        data: string;
+                    }[];
+                } | undefined;
+                height: string;
+                codespace: string;
+            }[]>;
         }>;
     };
     orchestrator: {
         /** @type {HostOf<Orchestrator['getChain']>} */
-        getChain(chainName: string): Vow<Chain<any> extends import("@endo/pass-style").Passable ? import("@endo/pass-style").Passable & Chain<any> : HostInterface<Chain<any>>>;
-        makeLocalAccount(): Vow<import("@endo/exo").Guarded<{
-            getAddress(): string;
-            getBalance(brand: Brand<"nat">): import("@agoric/vow").PromiseVow<Amount<"nat">>;
-            deposit(payment: ERef<Payment<"nat">>, optAmountShape?: Pattern): import("@agoric/vow").PromiseVow<Amount<"nat">>;
-            withdraw(amount: Amount<"nat">): import("@agoric/vow").PromiseVow<Payment<"nat">>;
-            executeTx<MT extends import("@agoric/cosmic-proto").TypedJson[]>(messages: MT): PromiseVowOfTupleMappedToGenerics<{ [K in keyof MT]: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<MT[K]>>; }>;
-            monitorTransfers(tap: import("@agoric/vats/src/bridge-target.js").TargetApp): import("@agoric/vow").PromiseVow<import("@agoric/vats/src/bridge-target.js").TargetRegistration>;
-        }>>;
+        getChain(chainName: string): Vow<HostInterface<Chain<any>>>;
         /** @type {HostOf<Orchestrator['getDenomInfo']>} */
-        getDenomInfo(denom: string): HostInterface<import("../orchestration-api.js").DenomInfo<"agoric" | "celestia" | "agoriclocal" | "cosmoshub" | "dydx" | "juno" | "neutron" | "noble" | "omniflixhub" | "osmosis" | "secretnetwork" | "stargaze" | "stride" | "umee", "agoric" | "celestia" | "agoriclocal" | "cosmoshub" | "dydx" | "juno" | "neutron" | "noble" | "omniflixhub" | "osmosis" | "secretnetwork" | "stargaze" | "stride" | "umee">>;
+        getDenomInfo(denom: string): HostInterface<import("../orchestration-api.js").DenomInfo<"agoric" | "celestia" | "cosmoshub" | "dydx" | "juno" | "neutron" | "noble" | "omniflixhub" | "osmosis" | "secretnetwork" | "stargaze" | "stride" | "umee", "agoric" | "celestia" | "cosmoshub" | "dydx" | "juno" | "neutron" | "noble" | "omniflixhub" | "osmosis" | "secretnetwork" | "stargaze" | "stride" | "umee">>;
         /** @type {HostOf<Orchestrator['asAmount']>} */
         asAmount: HostOf<Orchestrator["asAmount"]>;
     };
 }>;
+import type { ActualChainInfo } from './chain-hub.js';
+import type { IBCConnectionInfo } from '../types.js';
+import type { ChainInfo } from '../types.js';
 export {};
 //# 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":"AAmCA,0BAA0B;AAC1B;;;;;GAKG;AA0II,0CAhBI,IAAI,UACJ;IACV,cAAkB,EAAE,cAAc,CAAC;IACnC,QAAY,EAAE,QAAQ,CAAC;IACvB,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,WAAe,EAAE,QAAQ,CAAC,MAAM,EAAE,yBAAoB,CAAC,CAAC;IACxD,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;IArFE,2DAA2D;;QAEzD;;WAEG;qCADQ,gBAAgB,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAQtC;;;OAGG;;QAED;;;;;;WAMG;0HADQ,MAAM;;;;;;;QASjB,+CAA+C;;;;;;;;;;QAoB/C,mDAAmD;;QAanD,+CAA+C;kBAApC,OAAO,YAAY,CAAC,UAAU,CAAC,CAAC;;oBA2BlD;;;;;+BAMY,UAAU,CACtB,UAAc,CAAC,OAAO,sBAAsB,CAAC,CAC1C,CAAC,cAAc,CAAC;0BA7KG,mBAAmB;oCAEc,oBAAoB;8BADhC,gBAAgB;gCAI/B,gCAAgC;4BAEpC,kBAAkB;2BAKyB,aAAa;mCAVzB,oBAAoB;qCAI7B,6CAA6C;0CAIrD,yBAAyB;2CACxB,0BAA0B;6CAFxB,qBAAqB;kCALhC,cAAc;8BADb,aAAa;qCAFD,gBAAgB;uCAWQ,aAAa;yBATjD,aAAa;+BASuB,aAAa;kCAAb,aAAa;4BAVzB,oBAAoB;AAwB5E;;;;;;;;;;;;;;;;GAgBG;AACH,8CAhBW,IAAI,mHACJ;IACV,cAAkB,EAAE,cAAc,CAAC;IACnC,QAAY,EAAE,QAAQ,CAAC;IACvB,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,WAAe,EAAE,QAAQ,CAAC,MAAM,EAAE,yBAAoB,CAAC,CAAC;IACxD,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;IAkCE,2DAA2D;;QAEzD;;WAEG;qCADQ,gBAAgB,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAQtC;;;OAGG;;QAED;;;;;;WAMG;0HADQ,MAAM;;;;;;;QASjB,+CAA+C;;;;;;;;;;QAoB/C,mDAAmD;;QAanD,+CAA+C;kBAApC,OAAO,YAAY,CAAC,UAAU,CAAC,CAAC;;GAIhD"}
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["orchestrator.js"],"names":[],"mappings":"AAiCA,0BAA0B;AAC1B;;;;GAIG;AA2II,0CARI,IAAI,UACJ;IACN,QAAQ,EAAE,QAAQ,CAAC;IACnB,oBAAoB,EAAE,oBAAoB,CAAC;IAC3C,qBAAqB,EAAE,qBAAqB,CAAC;IAC7C,QAAQ,EAAE,QAAQ,CAAC;CACpB;IA1DI,+CAA+C;;IAsB/C,mDAAmD;;IAqBnD,+CAA+C;cAApC,OAAO,YAAY,CAAC,UAAU,CAAC,CAAC;GAoBlD;;;;;+BAMY,UAAU,CAClB,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAC1C,CAAC,cAAc,CAAC;0BA7KG,mBAAmB;8BACE,gBAAgB;0CASrB,yBAAyB;2CACxB,0BAA0B;8BARlC,aAAa;2BASuB,aAAa;mCAVzB,oBAAoB;yBAC5C,aAAa;kCASuB,aAAa;4BAVzB,oBAAoB;AAuB5E;;;;;;;;GAQG;AACH,8CARW,IAAI,0FACJ;IACN,QAAQ,EAAE,QAAQ,CAAC;IACnB,oBAAoB,EAAE,oBAAoB,CAAC;IAC3C,qBAAqB,EAAE,qBAAqB,CAAC;IAC7C,QAAQ,EAAE,QAAQ,CAAC;CACpB;IAwCE,2DAA2D;;QAEzD;;WAEG;qCADQ,gBAAgB,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;IAQtC;;;OAGG;;QAED;;;;;;WAMG;0HADQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;QASjB,+CAA+C;;QAsB/C,mDAAmD;;QAqBnD,+CAA+C;kBAApC,OAAO,YAAY,CAAC,UAAU,CAAC,CAAC;;GAKlD;qCArJ2C,gBAAgB;uCAWQ,aAAa;+BAAb,aAAa"}

package/src/exos/orchestrator.js

@@ -4,14 +4,12 @@ import { pickFacet } from '@agoric/vat-data';
 import { makeTracer } from '@agoric/internal';
 import { Shape as NetworkShape } from '@agoric/network';
 import { Fail, q } from '@endo/errors';
-import { E } from '@endo/far';
 import { M } from '@endo/patterns';
 import {
   DenomInfoShape,
   ChainInfoShape,
   DenomAmountShape,
   DenomShape,
-  LocalChainAccountShape,
 } from '../typeGuards.js';
 
 /**
@@ -36,7 +34,6 @@ const trace = makeTracer('Orchestrator');
 /** @see {Orchestrator} */
 export const OrchestratorI = M.interface('Orchestrator', {
   getChain: M.call(M.string()).returns(Vow$(ChainInfoShape)),
-  makeLocalAccount: M.call().returns(Vow$(LocalChainAccountShape)),
   getDenomInfo: M.call(DenomShape).returns(DenomInfoShape),
   asAmount: M.call(DenomAmountShape).returns(AmountShape),
 });
@@ -44,32 +41,30 @@ export const OrchestratorI = M.interface('Orchestrator', {
 /**
  * @param {Zone} zone
  * @param {{
- *   asyncFlowTools: AsyncFlowTools;
  *   chainHub: ChainHub;
- *   localchain: Remote<LocalChain>;
- *   chainByName: MapStore<string, HostInterface<Chain>>;
- *   makeRecorderKit: MakeRecorderKit;
  *   makeLocalChainFacade: MakeLocalChainFacade;
  *   makeRemoteChainFacade: MakeRemoteChainFacade;
- *   orchestrationService: Remote<CosmosInterchainService>;
- *   storageNode: Remote<StorageNode>;
- *   timerService: Remote<TimerService>;
  *   vowTools: VowTools;
- *   zcf: ZCF;
  * }} powers
  */
 const prepareOrchestratorKit = (
   zone,
   {
     chainHub,
-    localchain,
-    chainByName,
     makeLocalChainFacade,
     makeRemoteChainFacade,
     vowTools: { watch, asVow },
   },
-) =>
-  zone.exoClassKit(
+) => {
+  /**
+   * @template T
+   * @typedef {{ vow: Vow<T>; pending: true } | { value: T; pending: false }} MaybePendingValue
+   */
+
+  /** @type {MapStore<string, MaybePendingValue<HostInterface<Chain>>>} */
+  const chainByName = zone.mapStore('chainName');
+
+  return zone.exoClassKit(
     'Orchestrator',
     {
       orchestrator: OrchestratorI,
@@ -97,7 +92,7 @@ const prepareOrchestratorKit = (
          */
         onFulfilled(agoricChainInfo) {
           const it = makeLocalChainFacade(agoricChainInfo);
-          chainByName.init('agoric', it);
+          chainByName.set('agoric', harden({ value: it, pending: false }));
           return it;
         },
       },
@@ -115,30 +110,32 @@ const prepareOrchestratorKit = (
          */
         onFulfilled([_agoricChainInfo, remoteChainInfo, connectionInfo], name) {
           const it = makeRemoteChainFacade(remoteChainInfo, connectionInfo);
-          chainByName.init(name, it);
+          chainByName.set(name, harden({ value: it, pending: false }));
           return it;
         },
       },
       orchestrator: {
         /** @type {HostOf<Orchestrator['getChain']>} */
         getChain(name) {
-          if (chainByName.has(name)) {
-            return asVow(() => chainByName.get(name));
-          }
-          if (name === 'agoric') {
-            return watch(
-              chainHub.getChainInfo('agoric'),
-              this.facets.makeLocalChainFacadeWatcher,
-            );
-          }
-          return watch(
-            chainHub.getChainsAndConnection('agoric', name),
-            this.facets.makeRemoteChainFacadeWatcher,
-            name,
-          );
-        },
-        makeLocalAccount() {
-          return watch(E(localchain).makeAccount());
+          return asVow(() => {
+            if (chainByName.has(name)) {
+              const maybeChain = chainByName.get(name);
+              return maybeChain.pending ? maybeChain.vow : maybeChain.value;
+            }
+            const vow =
+              name === 'agoric'
+                ? watch(
+                    chainHub.getChainInfo('agoric'),
+                    this.facets.makeLocalChainFacadeWatcher,
+                  )
+                : watch(
+                    chainHub.getChainsAndConnection('agoric', name),
+                    this.facets.makeRemoteChainFacadeWatcher,
+                    name,
+                  );
+            chainByName.init(name, harden({ vow, pending: true }));
+            return vow;
+          });
         },
         /** @type {HostOf<Orchestrator['getDenomInfo']>} */
         getDenomInfo(denom) {
@@ -147,10 +144,18 @@ const prepareOrchestratorKit = (
           const { chainName, baseName, baseDenom, brand } = denomDetail;
           chainByName.has(chainName) ||
             Fail`use getChain(${q(chainName)}) before getDenomInfo(${q(denom)})`;
-          const chain = chainByName.get(chainName);
+          const maybeChain = chainByName.get(chainName);
+          if (maybeChain.pending) {
+            throw Fail`wait until getChain(${q(chainName)}) completes before getDenomInfo(${q(denom)})`;
+          }
+          const chain = maybeChain.value;
           chainByName.has(baseName) ||
             Fail`use getChain(${q(baseName)}) before getDenomInfo(${q(denom)})`;
-          const base = chainByName.get(baseName);
+          const maybeBase = chainByName.get(baseName);
+          if (maybeBase.pending) {
+            throw Fail`wait until getChain(${q(baseName)}) completes before getDenomInfo(${q(denom)})`;
+          }
+          const base = maybeBase.value;
           return harden({ chain, base, brand, baseDenom });
         },
         /** @type {HostOf<Orchestrator['asAmount']>} */
@@ -158,23 +163,16 @@ const prepareOrchestratorKit = (
       },
     },
   );
+};
 harden(prepareOrchestratorKit);
 
 /**
  * @param {Zone} zone
  * @param {{
- *   asyncFlowTools: AsyncFlowTools;
  *   chainHub: ChainHub;
- *   localchain: Remote<LocalChain>;
- *   chainByName: MapStore<string, HostInterface<Chain>>;
- *   makeRecorderKit: MakeRecorderKit;
  *   makeLocalChainFacade: MakeLocalChainFacade;
  *   makeRemoteChainFacade: MakeRemoteChainFacade;
- *   orchestrationService: Remote<CosmosInterchainService>;
- *   storageNode: Remote<StorageNode>;
- *   timerService: Remote<TimerService>;
  *   vowTools: VowTools;
- *   zcf: ZCF;
  * }} powers
  */
 export const prepareOrchestrator = (zone, powers) => {