@agoric/orchestration 0.1.1-dev-62c73f5.0 → 0.1.1-dev-0cfea88.0

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

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

package/src/exos/orchestrator.js

@@ -1,7 +1,7 @@
 /** @file ChainAccount exo */
 import { AmountShape } from '@agoric/ertp';
 import { makeTracer } from '@agoric/internal';
-import { V } from '@agoric/vow/vat.js';
+import { E } from '@endo/far';
 import { M } from '@endo/patterns';
 import {
   ChainInfoShape,
@@ -10,16 +10,18 @@ import {
   BrandInfoShape,
   DenomAmountShape,
 } from '../typeGuards.js';
+import { getChainsAndConnection } from './chain-hub.js';
 
 /**
  * @import {Zone} from '@agoric/base-zone';
  * @import {ChainHub} from './chain-hub.js';
  * @import {AsyncFlowTools} from '@agoric/async-flow';
- * @import {Vow} from '@agoric/vow';
+ * @import {Vow, VowTools} from '@agoric/vow';
  * @import {TimerService} from '@agoric/time';
  * @import {LocalChain} from '@agoric/vats/src/localchain.js';
  * @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 {MakeLocalOrchestrationAccountKit} from './local-orchestration-account.js';
  * @import {MakeLocalChainFacade} from './local-chain-facade.js';
@@ -50,44 +52,89 @@ export const OrchestratorI = M.interface('Orchestrator', {
  *   orchestrationService: Remote<OrchestrationService>;
  *   storageNode: Remote<StorageNode>;
  *   timerService: Remote<TimerService>;
+ *   vowTools: VowTools;
  *   zcf: ZCF;
  * }} powers
  */
-export const prepareOrchestrator = (
+export const prepareOrchestratorKit = (
   zone,
-  { chainHub, localchain, makeLocalChainFacade, makeRemoteChainFacade },
+  {
+    chainHub,
+    localchain,
+    makeLocalChainFacade,
+    makeRemoteChainFacade,
+    vowTools: { watch, when },
+  },
 ) =>
-  zone.exoClass(
+  zone.exoClassKit(
     'Orchestrator',
-    OrchestratorI,
+    {
+      orchestrator: OrchestratorI,
+      makeLocalChainFacadeWatcher: M.interface('makeLocalChainFacadeWatcher', {
+        onFulfilled: M.call(M.record())
+          .optional(M.arrayOf(M.undefined()))
+          .returns(M.any()), // FIXME narrow
+      }),
+      makeRemoteChainFacadeWatcher: M.interface(
+        'makeRemoteChainFacadeWatcher',
+        {
+          onFulfilled: M.call(M.arrayOf(M.record()))
+            .optional(M.arrayOf(M.undefined()))
+            .returns(M.any()), // FIXME narrow
+        },
+      ),
+    },
     () => {
       trace('making an Orchestrator');
       return {};
     },
     {
-      /** @type {Orchestrator['getChain']} */
-      getChain: async name => {
-        const agoricChainInfo = await chainHub.getChainInfo('agoric');
-
-        if (name === 'agoric') {
-          // @ts-expect-error XXX chainInfo generic
+      /** Waits for `chainInfo` and returns a LocalChainFacade */
+      makeLocalChainFacadeWatcher: {
+        /** @param {ChainInfo} agoricChainInfo */
+        onFulfilled(agoricChainInfo) {
           return makeLocalChainFacade(agoricChainInfo);
-        }
-
-        const remoteChainInfo = await chainHub.getChainInfo(name);
-        const connectionInfo = await chainHub.getConnectionInfo(
-          agoricChainInfo.chainId,
-          remoteChainInfo.chainId,
-        );
-
-        // @ts-expect-error XXX chainInfo generic
-        return makeRemoteChainFacade(remoteChainInfo, connectionInfo);
+        },
+      },
+      /**
+       * 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
+         */
+        onFulfilled([_agoricChainInfo, remoteChainInfo, connectionInfo]) {
+          return makeRemoteChainFacade(remoteChainInfo, connectionInfo);
+        },
       },
-      makeLocalAccount() {
-        return V(localchain).makeAccount();
+      orchestrator: {
+        /** @type {Orchestrator['getChain']} */
+        getChain(name) {
+          if (name === 'agoric') {
+            return when(
+              watch(
+                chainHub.getChainInfo('agoric'),
+                this.facets.makeLocalChainFacadeWatcher,
+              ),
+            );
+          }
+          return when(
+            watch(
+              getChainsAndConnection(chainHub, 'agoric', name),
+              this.facets.makeRemoteChainFacadeWatcher,
+            ),
+          );
+        },
+        makeLocalAccount() {
+          return when(watch(E(localchain).makeAccount()));
+        },
+        getBrandInfo: () => Fail`not yet implemented`,
+        asAmount: () => Fail`not yet implemented`,
       },
-      getBrandInfo: () => Fail`not yet implemented`,
-      asAmount: () => Fail`not yet implemented`,
     },
   );
-harden(prepareOrchestrator);
+harden(prepareOrchestratorKit);

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

@@ -1,84 +1,34 @@
 export function prepareRemoteChainFacade(zone: Zone, { makeCosmosOrchestrationAccount, orchestration, storageNode, timer }: {
-    makeCosmosOrchestrationAccount: (chainAddress: import("../orchestration-api.js").ChainAddress, bondDenom: string, io: {
-        account: import("../cosmos-api.js").IcaAccount;
-        storageNode: Remote<globalThis.StorageNode>;
-        icqConnection: import("@endo/exo").Guarded<{
-            getLocalAddress(): `/ibc-port/${string}`;
-            getRemoteAddress(): `/${string}ibc-port/${string}/ordered/${string}` | `/${string}ibc-port/${string}/unordered/${string}`;
-            query(msgs: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").RequestQuery>[]): Promise<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").ResponseQuery>[]>;
-        }> | undefined;
-        timer: Remote<TimerService>;
-    }) => import("@endo/exo").Guarded<{
-        asContinuingOffer(): {
-            publicSubscribers: {
-                account: {
-                    description: string;
-                    subscriber: globalThis.Subscriber<import("./cosmos-orchestration-account.js").ComosOrchestrationAccountNotification>;
-                    storagePath: Promise<string>;
-                };
-            };
-            invitationMakers: import("@endo/exo").Guarded<{
-                Delegate(validator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): Promise<Invitation<undefined, undefined>>;
-                Redelegate(srcValidator: import("../cosmos-api.js").CosmosValidatorAddress, dstValidator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): Promise<Invitation<undefined, undefined>>;
-                WithdrawReward(validator: import("../cosmos-api.js").CosmosValidatorAddress): Promise<Invitation<import("../orchestration-api.js").DenomAmount[], undefined>>;
-                Undelegate(delegations: Omit<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").Delegation, "delegatorAddress">[]): Promise<Invitation<undefined, undefined>>;
-                CloseAccount(): never;
-                TransferAccount(): never;
-            }>;
-            holder: import("@endo/exo").Guarded<any>;
-        };
-        getPublicTopics(): {
-            account: {
-                description: string;
-                subscriber: globalThis.Subscriber<import("./cosmos-orchestration-account.js").ComosOrchestrationAccountNotification>;
-                storagePath: Promise<string>;
-            };
-        };
-        getAddress(): import("../orchestration-api.js").ChainAddress;
-        delegate(validator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): Promise<undefined>;
-        deposit(payment: any): Promise<void>;
-        getBalances(): Promise<never>;
-        redelegate(srcValidator: import("../cosmos-api.js").CosmosValidatorAddress, dstValidator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): Promise<undefined>;
-        withdrawReward(validator: import("../cosmos-api.js").CosmosValidatorAddress): Promise<import("../orchestration-api.js").DenomAmount[]>;
-        getBalance(denom: import("../orchestration-api.js").DenomArg): Promise<import("../orchestration-api.js").DenomAmount>;
-        send(toAccount: any, amount: any): never;
-        transfer(amount: any, msg: any): never;
-        transferSteps(amount: any, msg: any): never;
-        withdrawRewards(): never;
-        undelegate(delegations: Omit<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").Delegation, "delegatorAddress">[]): Promise<undefined>;
-    }>;
-    orchestration: Remote<import("@endo/exo").Guarded<{
-        makeAccount(chainId: string, hostConnectionId: `connection-${number}`, controllerConnectionId: `connection-${number}`): Promise<import("../cosmos-api.js").IcaAccount>;
-        provideICQConnection(controllerConnectionId: `connection-${number}`): Promise<import("@endo/exo").Guarded<{
-            getLocalAddress(): `/ibc-port/${string}`;
-            getRemoteAddress(): `/${string}ibc-port/${string}/ordered/${string}` | `/${string}ibc-port/${string}/unordered/${string}`;
-            query(msgs: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").RequestQuery>[]): Promise<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").ResponseQuery>[]>;
-        }>>;
-    }>>;
-    storageNode: Remote<globalThis.StorageNode>;
+    makeCosmosOrchestrationAccount: ReturnType<typeof prepareCosmosOrchestrationAccount>;
+    orchestration: Remote<OrchestrationService>;
+    storageNode: Remote<StorageNode>;
     timer: Remote<TimerService>;
 }): (remoteChainInfo: Readonly<{
     chainId: string;
-    connections?: Record<string, IBCConnectionInfo> | undefined;
-    icqEnabled?: boolean | undefined;
-    stakingTokens?: readonly {
+    connections?: Record<string, IBCConnectionInfo>;
+    icqEnabled?: boolean;
+    stakingTokens?: Readonly<Array<{
         denom: string;
-    }[] | undefined;
+    }>>;
 }>, connectionInfo: IBCConnectionInfo) => import("@endo/exo").Guarded<{
     getChainInfo(): Promise<Readonly<{
         chainId: string;
-        connections?: Record<string, IBCConnectionInfo> | undefined;
-        icqEnabled?: boolean | undefined;
-        stakingTokens?: readonly {
+        connections?: Record<string, IBCConnectionInfo>;
+        icqEnabled?: boolean;
+        stakingTokens?: Readonly<Array<{
             denom: string;
-        }[] | undefined;
+        }>>;
     }>>;
     /** @returns {Promise<OrchestrationAccount<ChainInfo>>} */
-    makeAccount(): Promise<import("../orchestration-api.js").OrchestrationAccountI>;
+    makeAccount(): Promise<OrchestrationAccount<ChainInfo>>;
 }>;
 export type MakeRemoteChainFacade = ReturnType<typeof prepareRemoteChainFacade>;
 import type { Zone } from '@agoric/base-zone';
+import type { prepareCosmosOrchestrationAccount } from './cosmos-orchestration-account.js';
+import type { OrchestrationService } from '../service.js';
 import type { Remote } from '@agoric/internal';
 import type { TimerService } from '@agoric/time';
 import type { IBCConnectionInfo } from '../types.js';
+import type { ChainInfo } from '../types.js';
+import type { OrchestrationAccount } from '../types.js';
 //# sourceMappingURL=remote-chain-facade.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"remote-chain-facade.d.ts","sourceRoot":"","sources":["remote-chain-facade.js"],"names":[],"mappings":"AAgCO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsBD,0DAA0D;;GAwB7D;oCAEW,UAAU,CAAC,OAAO,wBAAwB,CAAC;0BAzElC,mBAAmB;4BAEjB,kBAAkB;kCADZ,cAAc;uCAIyC,aAAa"}
+{"version":3,"file":"remote-chain-facade.d.ts","sourceRoot":"","sources":["remote-chain-facade.js"],"names":[],"mappings":"AAgCO,+CAVI,IAAI,yEACJ;IACV,8BAAkC,EAAE,UAAU,CAC9C,wCAA8C,CACzC,CAAC;IACN,aAAiB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IAChD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,KAAS,EAAE,OAAO,YAAY,CAAC,CAAC;CAC7B;;;;;;;;;;;;;;;;IAwBE,0DAA0D;mBAA5C,OAAO,CAAC,qBAAqB,SAAS,CAAC,CAAC;GAwBzD;oCAEW,UAAU,CAAC,OAAO,wBAAwB,CAAC;0BAzElC,mBAAmB;uDAIU,mCAAmC;0CADhD,eAAe;4BAD7B,kBAAkB;kCADZ,cAAc;uCAIyC,aAAa;+BAAb,aAAa;0CAAb,aAAa"}

package/src/facade.d.ts

@@ -1,192 +1,18 @@
-export function makeOrchestrationFacade({ zone, timerService, zcf, storageNode, orchestrationService, localchain, chainHub, makeLocalOrchestrationAccountKit, makeRecorderKit, makeLocalChainFacade, makeRemoteChainFacade, asyncFlowTools, }: {
+export function makeOrchestrationFacade({ zone, timerService, zcf, storageNode, orchestrationService, localchain, chainHub, makeLocalOrchestrationAccountKit, makeRecorderKit, makeLocalChainFacade, makeRemoteChainFacade, vowTools, asyncFlowTools, }: {
     zone: Zone;
     timerService: Remote<TimerService>;
     zcf: ZCF;
-    storageNode: Remote<globalThis.StorageNode>;
-    orchestrationService: Remote<import("@endo/exo").Guarded<{
-        makeAccount(chainId: string, hostConnectionId: `connection-${number}`, controllerConnectionId: `connection-${number}`): Promise<import("./cosmos-api.js").IcaAccount>;
-        provideICQConnection(controllerConnectionId: `connection-${number}`): Promise<import("@endo/exo").Guarded<{
-            getLocalAddress(): `/ibc-port/${string}`;
-            getRemoteAddress(): `/${string}ibc-port/${string}/ordered/${string}` | `/${string}ibc-port/${string}/unordered/${string}`;
-            query(msgs: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").RequestQuery>[]): Promise<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").ResponseQuery>[]>;
-        }>>;
-    }>>;
-    localchain: Remote<import("@endo/exo").Guarded<{
-        makeAccount(): import("@agoric/vow").PromiseVow<import("@endo/exo").Guarded<{
-            getAddress(): string;
-            getBalance(brand: Brand<"nat">): import("@agoric/vow").PromiseVow<import("@agoric/ertp/src/types.js").NatAmount>;
-            deposit(payment: Payment<"nat">, optAmountShape?: Pattern): import("@agoric/vow").PromiseVow<import("@agoric/ertp/src/types.js").NatAmount>;
-            withdraw(amount: Amount<"nat">): import("@agoric/vow").PromiseVow<globalThis.Payment<"nat">>;
-            executeTx<MT extends {
-                '@type': string;
-            }[]>(messages: MT): import("@agoric/vats/src/localchain.js").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>;
-        }>>;
-        query<T extends {
-            '@type': string;
-        } = {
-            '@type': string;
-        }>(request: T): import("@agoric/vow").PromiseVow<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<T>>>;
-        queryMany<RT extends {
-            '@type': string;
-        }[]>(requests: RT): import("@agoric/vats/src/localchain.js").PromiseVowOfTupleMappedToGenerics<{ [K_1 in keyof RT]: import("@agoric/cosmic-proto").JsonSafe<{
-            error?: string | undefined;
-            reply: import("@agoric/cosmic-proto").ResponseTo<RT[K_1]>;
-        }>; }>;
-    }>>;
+    storageNode: Remote<StorageNode>;
+    orchestrationService: Remote<OrchestrationService>;
+    localchain: Remote<LocalChain>;
     chainHub: import("./exos/chain-hub.js").ChainHub;
-    makeLocalOrchestrationAccountKit: (args_0: {
-        account: import("@endo/exo").Guarded<{
-            getAddress(): string;
-            getBalance(brand: Brand<"nat">): import("@agoric/vow").PromiseVow<import("@agoric/ertp/src/types.js").NatAmount>;
-            deposit(payment: Payment<"nat">, optAmountShape?: Pattern): import("@agoric/vow").PromiseVow<import("@agoric/ertp/src/types.js").NatAmount>;
-            withdraw(amount: Amount<"nat">): import("@agoric/vow").PromiseVow<globalThis.Payment<"nat">>;
-            executeTx<MT extends {
-                '@type': string;
-            }[]>(messages: MT): import("@agoric/vats/src/localchain.js").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>;
-        }>;
-        address: import("./orchestration-api.js").ChainAddress;
-        storageNode: Remote<globalThis.StorageNode>;
-    }) => import("@endo/exo").GuardedKit<{
-        invitationMakers: {
-            Delegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<Record<unknown, unknown>, undefined>>;
-            Undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<void | import("@agoric/time").TimestampRecord | Vow<void | import("@agoric/time").TimestampRecord>, undefined>>;
-            CloseAccount(): never;
-        };
-        undelegateWatcher: {
-            onFulfilled(response: [import("@agoric/cosmic-proto/cosmos/staking/v1beta1/tx.js").MsgUndelegateResponse & {
-                '@type': "/cosmos.staking.v1beta1.MsgUndelegateResponse";
-            }]): Promise<import("@agoric/time").TimestampRecord>;
-        };
-        getChainInfoWatcher: {
-            onFulfilled(agoricChainInfo: ChainInfo, { destination }: {
-                destination: import("./orchestration-api.js").ChainAddress;
-            }): Promise<IBCConnectionInfo>;
-        };
-        getTimeoutTimestampWatcher: {
-            onFulfilled(timeoutTimestamp: bigint, { opts }: {
-                opts: import("./cosmos-api.js").IBCMsgTransferOptions;
-            }): bigint;
-        };
-        transferWatcher: {
-            onFulfilled([{ transferChannel }, timeoutTimestamp]: [{
-                transferChannel: {
-                    portId: string;
-                    channelId: `channel-${number}`;
-                    counterPartyPortId: string;
-                    counterPartyChannelId: `channel-${number}`;
-                    ordering: import("@agoric/cosmic-proto/ibc/core/channel/v1/channel.js").Order;
-                    state: import("@agoric/cosmic-proto/ibc/core/channel/v1/channel.js").State;
-                    version: string;
-                };
-            }, bigint], { opts, amount, destination }: {
-                destination: import("./orchestration-api.js").ChainAddress;
-                opts: import("./cosmos-api.js").IBCMsgTransferOptions;
-                amount: import("./orchestration-api.js").DenomAmount;
-            }): import("@agoric/vats/src/localchain.js").PromiseVowOfTupleMappedToGenerics<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/ibc/applications/transfer/v1/tx.js").MsgTransferResponse & {
-                '@type': "/ibc.applications.transfer.v1.MsgTransferResponse";
-            }>[]>;
-        };
-        extractFirstResultWatcher: {
-            onFulfilled(results: Record<unknown, unknown>[]): Record<unknown, unknown>;
-        };
-        returnVoidWatcher: {
-            onFulfilled(results: Record<unknown, unknown>[]): undefined;
-        };
-        holder: {
-            getBalance(denom: DenomArg): Promise<import("./orchestration-api.js").DenomAmount>;
-            getBalances(): never;
-            getPublicTopics(): {
-                account: {
-                    description: string;
-                    subscriber: globalThis.Subscriber<import("./exos/local-orchestration-account.js").LocalChainAccountNotification>;
-                    storagePath: Promise<string>;
-                };
-            };
-            delegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Record<unknown, unknown>>;
-            undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): import("@agoric/vow").PromiseVow<void | import("@agoric/time").TimestampRecord>;
-            deposit(payment: globalThis.Payment<"nat">): Promise<void>;
-            withdraw(amount: Amount<"nat">): import("@agoric/vow").PromiseVow<globalThis.Payment<"nat">>;
-            executeTx<MT extends {
-                '@type': string;
-            }[]>(messages: MT): import("@agoric/vats/src/localchain.js").PromiseVowOfTupleMappedToGenerics<{ [K in keyof MT]: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<MT[K]>>; }>;
-            getAddress(): import("./orchestration-api.js").ChainAddress;
-            send(toAccount: any, amount: any): Promise<void>;
-            transfer(amount: import("./orchestration-api.js").AmountArg, destination: import("./orchestration-api.js").ChainAddress, opts?: import("./cosmos-api.js").IBCMsgTransferOptions | undefined): Promise<void>;
-            transferSteps(amount: AmountArg, msg: TransferMsg): Promise<void>;
-        };
-    }>;
-    makeRecorderKit: <T_1>(storageNode: StorageNode | Awaited<import("@endo/far").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T_1> | undefined) => RecorderKit<T_1>;
+    makeLocalOrchestrationAccountKit: MakeLocalOrchestrationAccountKit;
+    makeRecorderKit: MakeRecorderKit;
     makeCosmosOrchestrationAccount: any;
-    makeLocalChainFacade: (localChainInfo: Readonly<{
-        chainId: string;
-        connections?: Record<string, IBCConnectionInfo> | undefined;
-        icqEnabled?: boolean | undefined;
-        stakingTokens?: readonly {
-            denom: string;
-        }[] | undefined;
-    }>) => import("@endo/exo").Guarded<{
-        getChainInfo(): Promise<Readonly<{
-            chainId: string;
-            connections?: Record<string, IBCConnectionInfo> | undefined;
-            icqEnabled?: boolean | undefined;
-            stakingTokens?: readonly {
-                denom: string;
-            }[] | undefined;
-        }>>;
-        makeAccount(): Promise<import("./orchestration-api.js").OrchestrationAccountI>;
-    }>;
-    makeRemoteChainFacade: (remoteChainInfo: Readonly<{
-        chainId: string;
-        connections?: Record<string, IBCConnectionInfo> | undefined;
-        icqEnabled?: boolean | undefined;
-        stakingTokens?: readonly {
-            denom: string;
-        }[] | undefined;
-    }>, connectionInfo: IBCConnectionInfo) => import("@endo/exo").Guarded<{
-        getChainInfo(): Promise<Readonly<{
-            chainId: string;
-            connections?: Record<string, IBCConnectionInfo> | undefined;
-            icqEnabled?: boolean | undefined;
-            stakingTokens?: readonly {
-                denom: string;
-            }[] | undefined;
-        }>>;
-        makeAccount(): Promise<import("./orchestration-api.js").OrchestrationAccountI>;
-    }>;
-    asyncFlowTools: {
-        prepareAsyncFlowKit: (zone: Zone, tag: string, guestAsyncFunc: import("../../../node_modules/@agoric/async-flow/src/types.js").GuestAsyncFunc, options?: {
-            startEager?: boolean | undefined;
-        } | undefined) => (activationArgs: any) => import("@endo/exo").GuardedKit<{
-            flow: {
-                getFlowState(): import("../../../node_modules/@agoric/async-flow/src/types.js").FlowState;
-                restart(eager?: boolean | undefined): void;
-                wake(): void;
-                getOutcome(): Vow<any>;
-                dump(): ([op: "doFulfill", vow: Vow<import("@endo/pass-style").Passable>, fulfillment: import("@endo/pass-style").Passable] | [op: "doReject", vow: Vow<import("@endo/pass-style").Passable>, reason: import("@endo/pass-style").Passable] | [op: "doReturn", callIndex: number, result: import("@endo/pass-style").Passable] | [op: "doThrow", callIndex: number, problem: import("@endo/pass-style").Passable] | [op: "checkCall", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number])[];
-                getOptFatalProblem(): any;
-            };
-            admin: {
-                reset(): void;
-                complete(): void;
-                panic(fatalProblem: any): never;
-            };
-            wakeWatcher: {
-                onFulfilled(_fulfillment: any): void;
-                onRejected(_fulfillment: any): void;
-            };
-        }>;
-        asyncFlow: (zone: Zone, tag: string, guestFunc: import("../../../node_modules/@agoric/async-flow/src/types.js").GuestAsyncFunc, options?: {
-            startEager?: boolean | undefined;
-        } | undefined) => import("../../../node_modules/@agoric/async-flow/src/types.js").HostAsyncFuncWrapper;
-        adminAsyncFlow: import("@endo/exo").Guarded<{
-            getFailures(): import("@endo/patterns").CopyMap<any, import("@endo/pass-style").Passable>;
-            wakeAll(): void;
-            getFlowForOutcomeVow(outcomeVow: any): any;
-        }>;
-        allWokenP: Promise<void>;
-    };
+    makeLocalChainFacade: MakeLocalChainFacade;
+    makeRemoteChainFacade: MakeRemoteChainFacade;
+    vowTools: VowTools;
+    asyncFlowTools: AsyncFlowTools;
 }): {
     /**
      * @template Context
@@ -203,9 +29,13 @@ 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 { Vow } from '@agoric/vow';
-import type { ChainInfo } from './types.js';
-import type { IBCConnectionInfo } from './types.js';
-import type { RecorderKit } from '@agoric/zoe/src/contractSupport/recorder.js';
+import type { OrchestrationService } from './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';
+import type { MakeLocalChainFacade } from './exos/local-chain-facade.js';
+import type { MakeRemoteChainFacade } from './exos/remote-chain-facade.js';
+import type { VowTools } from '@agoric/vow';
+import type { AsyncFlowTools } from '@agoric/async-flow';
 import type { Orchestrator } from './types.js';
 //# sourceMappingURL=facade.d.ts.map

package/src/facade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"facade.d.ts","sourceRoot":"","sources":["facade.js"],"names":[],"mappings":"AAuCO;;;SAbG,GAAG;;;;;;;;;;;;;8BAyEuG,MAAM,KAAK,CAAC;6BAA6gB,QAAQ,KAAK,CAAC,mBAA6B,OAAO;6BAAwjB,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;;;;oBAAqjG,CAAC;;;uBAA6lB,EAAE;;;;;cArEzkL,OAAO,qBAAqB,EAAE,QAAQ;;;;8BAqE+D,MAAM,KAAK,CAAC;6BAA6gB,QAAQ,KAAK,CAAC,mBAA6B,OAAO;6BAAwjB,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;;;;2DAA2H,OAAO,KAAK,CAAC;6DAAid,OAAO,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAgkG,wBAAwB,EAAE;;;iCAAsZ,wBAAwB,EAAE;;;8BAAngJ,QAAS;;;;;;;;;2DAAmwL,OAAO,KAAK,CAAC;6DAAksB,OAAO,KAAK,CAAC;;6BAAjyN,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;kCAA46B,SAAU,OAAM,WAAY;;;wCAA/xC,WAAW,GAAE,QAAS,OAAO,WAAW,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC;oCAlEroD,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgDpC;;;;;;;;OAQG;gBAFkC,OAAO,EACrB,IAAI,6BAJhB,MAAM,OAGoB,OAAO,AAD1B,gCACmB,OAAO,WACrB,IAAI,AADgC,KAAK,MAAM,GACzD,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,OAAO,CAAC;EAQnD;kCAEa,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BA1FjC,cAAc;kCAEN,cAAc;4BAIpB,kBAAkB;yBALX,aAAa;+BAO8D,YAAY;uCAAZ,YAAY;iCAHxE,6CAA6C;kCAGe,YAAY"}
+{"version":3,"file":"facade.d.ts","sourceRoot":"","sources":["facade.js"],"names":[],"mappings":"AAwCO,yPAjBI;IACV,IAAQ,EAAE,IAAI,CAAC;IACf,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,GAAO,EAAE,GAAG,CAAC;IACb,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,QAAY,EAAE,OAAO,qBAAqB,EAAE,QAAQ,CAAC;IACrD,gCAAoC,EAAE,gCAAgC,CAAC;IACvE,eAAmB,EAAE,eAAe,CAAC;IACrC,8BAAkC,EAAE,GAAG,CAAC;IACxC,oBAAwB,EAAE,oBAAoB,CAAC;IAC/C,qBAAyB,EAAE,qBAAqB,CAAC;IACjD,QAAY,EAAE,QAAQ,CAAC;IACvB,cAAkB,EAAE,cAAc,CAAC;CAChC;IA+CA;;;;;;;;OAQG;gBAPU,OAAO,EACC,IAAI,SAAX,GAAG,EAAG,eACT,MAAM,OAEN,OAAO,MACP,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,IAAI,KAAK,MAAM,GACzD,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,OAAO,CAAC;EAQnD;kCAEa,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BA9FjC,cAAc;kCAEN,cAAc;4BAIpB,kBAAkB;0CACJ,cAAc;gCAHxB,gCAAgC;sDAOV,uCAAuC;qCAN3C,6CAA6C;0CAIrD,8BAA8B;2CAC7B,+BAA+B;8BATvC,aAAa;oCAFZ,oBAAoB;kCASsD,YAAY"}

package/src/facade.js

@@ -1,8 +1,8 @@
 /** @file Orchestration service */
 
 import { Fail } from '@agoric/assert';
-
-import { prepareOrchestrator } from './exos/orchestrator.js';
+import { pickFacet } from '@agoric/vat-data';
+import { prepareOrchestratorKit } from './exos/orchestrator.js';
 
 /**
  * @import {AsyncFlowTools} from '@agoric/async-flow';
@@ -34,6 +34,7 @@ import { prepareOrchestrator } from './exos/orchestrator.js';
  *   makeCosmosOrchestrationAccount: any;
  *   makeLocalChainFacade: MakeLocalChainFacade;
  *   makeRemoteChainFacade: MakeRemoteChainFacade;
+ *   vowTools: VowTools;
  *   asyncFlowTools: AsyncFlowTools;
  * }} powers
  */
@@ -49,6 +50,7 @@ export const makeOrchestrationFacade = ({
   makeRecorderKit,
   makeLocalChainFacade,
   makeRemoteChainFacade,
+  vowTools,
   asyncFlowTools,
 }) => {
   (zone &&
@@ -65,7 +67,7 @@ export const makeOrchestrationFacade = ({
     asyncFlowTools) ||
     Fail`params missing`;
 
-  const makeOrchestrator = prepareOrchestrator(zone, {
+  const makeOrchestratorKit = prepareOrchestratorKit(zone, {
     asyncFlowTools,
     chainHub,
     localchain,
@@ -75,8 +77,10 @@ export const makeOrchestrationFacade = ({
     orchestrationService,
     storageNode,
     timerService,
+    vowTools,
     zcf,
   });
+  const makeOrchestrator = pickFacet(makeOrchestratorKit, 'orchestrator');
 
   return {
     /**