@agoric/orchestration 0.1.1-calypso-dev-84eb287.0

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

@@ -0,0 +1,144 @@
+export function prepareRemoteChainFacade(zone: Zone, powers: RemoteChainFacadePowers): (remoteChainInfo: Readonly<{
+    chainId: string;
+    connections?: Record<string, IBCConnectionInfo>;
+    icqEnabled?: boolean;
+    stakingTokens?: Readonly<Array<{
+        denom: string;
+    }>>;
+}>, connectionInfo: IBCConnectionInfo) => ReturnType<(remoteChainInfo: Readonly<{
+    chainId: string;
+    connections?: Record<string, IBCConnectionInfo>;
+    icqEnabled?: boolean;
+    stakingTokens?: Readonly<Array<{
+        denom: string;
+    }>>;
+}>, connectionInfo: IBCConnectionInfo) => import("@endo/exo").GuardedKit<{
+    public: {
+        getChainInfo(): Vow<Readonly<{
+            chainId: string;
+            connections?: Record<string, IBCConnectionInfo>;
+            icqEnabled?: boolean;
+            stakingTokens?: Readonly<Array<{
+                denom: string;
+            }>>;
+        }>>;
+        /** @returns {Vow<PromiseToVow<OrchestrationAccount<ChainInfo>>>} */
+        makeAccount(): Vow<PromiseToVow<OrchestrationAccount<ChainInfo>>>;
+    };
+    makeAccountWatcher: {
+        /**
+         * @param {IcaAccount} account
+         * @param {Denom} stakingDenom
+         */
+        onFulfilled(account: IcaAccount, stakingDenom: Denom): Vow<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<Vow<undefined>, undefined>>;
+                    Redelegate(srcValidator: import("../cosmos-api.js").CosmosValidatorAddress, dstValidator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): Promise<Invitation<Vow<undefined>, undefined>>;
+                    WithdrawReward(validator: import("../cosmos-api.js").CosmosValidatorAddress): Promise<Invitation<Vow<import("../orchestration-api.js").DenomAmount[]>, undefined>>;
+                    Undelegate(delegations: Omit<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").Delegation, "delegatorAddress">[]): Promise<Invitation<Vow<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(): ChainAddress;
+            delegate(validator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): Vow<undefined>;
+            deposit(payment: any): void;
+            getBalances(): Vow<never>;
+            redelegate(srcValidator: import("../cosmos-api.js").CosmosValidatorAddress, dstValidator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): Vow<undefined>;
+            withdrawReward(validator: import("../cosmos-api.js").CosmosValidatorAddress): Vow<import("../orchestration-api.js").DenomAmount[]>;
+            getBalance(denom: import("../orchestration-api.js").DenomArg): Vow<import("../orchestration-api.js").DenomAmount>;
+            send(toAccount: any, amount: any): Vow<never>;
+            transfer(amount: any, msg: any): Vow<never>;
+            transferSteps(amount: any, msg: any): Vow<never>;
+            withdrawRewards(): Vow<never>;
+            undelegate(delegations: Omit<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").Delegation, "delegatorAddress">[]): Vow<undefined>;
+        }>>;
+    };
+    getAddressWatcher: {
+        /**
+         * @param {ChainAddress} chainAddress
+         * @param {{ stakingDenom: Denom; account: IcaAccount }} ctx
+         */
+        onFulfilled(chainAddress: ChainAddress, { account, stakingDenom }: {
+            stakingDenom: Denom;
+            account: IcaAccount;
+        }): 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<Vow<undefined>, undefined>>;
+                    Redelegate(srcValidator: import("../cosmos-api.js").CosmosValidatorAddress, dstValidator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): Promise<Invitation<Vow<undefined>, undefined>>;
+                    WithdrawReward(validator: import("../cosmos-api.js").CosmosValidatorAddress): Promise<Invitation<Vow<import("../orchestration-api.js").DenomAmount[]>, undefined>>;
+                    Undelegate(delegations: Omit<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").Delegation, "delegatorAddress">[]): Promise<Invitation<Vow<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(): ChainAddress;
+            delegate(validator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): Vow<undefined>;
+            deposit(payment: any): void;
+            getBalances(): Vow<never>;
+            redelegate(srcValidator: import("../cosmos-api.js").CosmosValidatorAddress, dstValidator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): Vow<undefined>;
+            withdrawReward(validator: import("../cosmos-api.js").CosmosValidatorAddress): Vow<import("../orchestration-api.js").DenomAmount[]>;
+            getBalance(denom: import("../orchestration-api.js").DenomArg): Vow<import("../orchestration-api.js").DenomAmount>;
+            send(toAccount: any, amount: any): Vow<never>;
+            transfer(amount: any, msg: any): Vow<never>;
+            transferSteps(amount: any, msg: any): Vow<never>;
+            withdrawRewards(): Vow<never>;
+            undelegate(delegations: Omit<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").Delegation, "delegatorAddress">[]): Vow<undefined>;
+        }>;
+    };
+}>>["public"];
+export type RemoteChainFacadePowers = {
+    makeCosmosOrchestrationAccount: ReturnType<typeof prepareCosmosOrchestrationAccount>;
+    orchestration: Remote<OrchestrationService>;
+    storageNode: Remote<StorageNode>;
+    timer: Remote<TimerService>;
+    vowTools: VowTools;
+};
+export type MakeRemoteChainFacade = ReturnType<typeof prepareRemoteChainFacade>;
+import type { Zone } from '@agoric/base-zone';
+import type { IBCConnectionInfo } from '../types.js';
+import type { Vow } from '@agoric/vow';
+import type { ChainInfo } from '../types.js';
+import type { OrchestrationAccount } from '../types.js';
+import type { PromiseToVow } from '../types.js';
+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 { Remote } from '@agoric/internal';
+import type { TimerService } from '@agoric/time';
+import type { VowTools } from '@agoric/vow';
+//# sourceMappingURL=remote-chain-facade.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,145 @@
+/** @file ChainAccount exo */
+import { makeTracer } from '@agoric/internal';
+import { E } from '@endo/far';
+import { M } from '@endo/patterns';
+import { pickFacet } from '@agoric/vat-data';
+import { VowShape } from '@agoric/vow';
+import { ChainFacadeI } from '../typeGuards.js';
+
+/**
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {TimerService} from '@agoric/time';
+ * @import {Remote} from '@agoric/internal';
+ * @import {Vow, VowTools} from '@agoric/vow';
+ * @import {OrchestrationService} from '../service.js';
+ * @import {prepareCosmosOrchestrationAccount} from './cosmos-orchestration-account.js';
+ * @import {ChainInfo, CosmosChainInfo, IBCConnectionInfo, OrchestrationAccount, ChainAddress, IcaAccount, PromiseToVow, Denom} from '../types.js';
+ */
+
+const { Fail } = assert;
+const trace = makeTracer('RemoteChainFacade');
+
+/** @type {any} */
+const anyVal = null;
+
+/**
+ * @typedef {{
+ *   makeCosmosOrchestrationAccount: ReturnType<
+ *     typeof prepareCosmosOrchestrationAccount
+ *   >;
+ *   orchestration: Remote<OrchestrationService>;
+ *   storageNode: Remote<StorageNode>;
+ *   timer: Remote<TimerService>;
+ *   vowTools: VowTools;
+ * }} RemoteChainFacadePowers
+ */
+
+/**
+ * @param {Zone} zone
+ * @param {RemoteChainFacadePowers} powers
+ */
+const prepareRemoteChainFacadeKit = (
+  zone,
+  {
+    makeCosmosOrchestrationAccount,
+    orchestration,
+    storageNode,
+    timer,
+    vowTools: { asVow, watch },
+  },
+) =>
+  zone.exoClassKit(
+    'RemoteChainFacade',
+    {
+      public: ChainFacadeI,
+      makeAccountWatcher: M.interface('makeAccountWatcher', {
+        onFulfilled: M.call(M.remotable())
+          .optional(M.string())
+          .returns(VowShape),
+      }),
+      getAddressWatcher: M.interface('makeAccountWatcher', {
+        onFulfilled: M.call(M.record())
+          .optional({ stakingDenom: M.string(), account: M.remotable() })
+          .returns(M.remotable()),
+      }),
+    },
+    /**
+     * @param {CosmosChainInfo} remoteChainInfo
+     * @param {IBCConnectionInfo} connectionInfo
+     */
+    (remoteChainInfo, connectionInfo) => {
+      trace('making a RemoteChainFacade');
+      return { remoteChainInfo, connectionInfo };
+    },
+    {
+      public: {
+        getChainInfo() {
+          return watch(this.state.remoteChainInfo);
+        },
+
+        /** @returns {Vow<PromiseToVow<OrchestrationAccount<ChainInfo>>>} */
+        makeAccount() {
+          // TODO #9449 fix types
+          // @ts-expect-error Type 'Vow<Voidless>' is not assignable to type 'Vow<OrchestrationAccountI>'
+          return asVow(() => {
+            const { remoteChainInfo, connectionInfo } = this.state;
+            const stakingDenom = remoteChainInfo.stakingTokens?.[0]?.denom;
+            if (!stakingDenom) {
+              throw Fail`chain info lacks staking denom`;
+            }
+
+            return watch(
+              E(orchestration).makeAccount(
+                remoteChainInfo.chainId,
+                connectionInfo.id,
+                connectionInfo.counterparty.connection_id,
+              ),
+              this.facets.makeAccountWatcher,
+              stakingDenom,
+            );
+          });
+        },
+      },
+      makeAccountWatcher: {
+        /**
+         * @param {IcaAccount} account
+         * @param {Denom} stakingDenom
+         */
+        onFulfilled(account, stakingDenom) {
+          return watch(E(account).getAddress(), this.facets.getAddressWatcher, {
+            stakingDenom,
+            account,
+          });
+        },
+      },
+      getAddressWatcher: {
+        /**
+         * @param {ChainAddress} chainAddress
+         * @param {{ stakingDenom: Denom; account: IcaAccount }} ctx
+         */
+        onFulfilled(chainAddress, { account, stakingDenom }) {
+          return makeCosmosOrchestrationAccount(chainAddress, stakingDenom, {
+            account,
+            storageNode,
+            // FIXME provide real ICQ connection
+            // FIXME make Query Connection available via chain, not orchestrationAccount
+            icqConnection: anyVal,
+            timer,
+          });
+        },
+      },
+    },
+  );
+harden(prepareRemoteChainFacadeKit);
+
+/**
+ * @param {Zone} zone
+ * @param {RemoteChainFacadePowers} powers
+ */
+export const prepareRemoteChainFacade = (zone, powers) => {
+  const makeLocalChainFacadeKit = prepareRemoteChainFacadeKit(zone, powers);
+  return pickFacet(makeLocalChainFacadeKit, 'public');
+};
+harden(prepareRemoteChainFacade);
+
+/** @typedef {ReturnType<typeof prepareRemoteChainFacade>} MakeRemoteChainFacade */

package/src/facade.d.ts

@@ -0,0 +1,57 @@
+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<StorageNode>;
+    orchestrationService: Remote<OrchestrationService>;
+    localchain: Remote<LocalChain>;
+    chainHub: import("./exos/chain-hub.js").ChainHub;
+    makeLocalOrchestrationAccountKit: MakeLocalOrchestrationAccountKit;
+    makeRecorderKit: MakeRecorderKit;
+    makeCosmosOrchestrationAccount: any;
+    makeLocalChainFacade: MakeLocalChainFacade;
+    makeRemoteChainFacade: MakeRemoteChainFacade;
+    vowTools: VowTools;
+    asyncFlowTools: AsyncFlowTools;
+}): {
+    /**
+     * @template GuestReturn
+     * @template HostReturn
+     * @template GuestContext
+     * @template HostContext
+     * @template {any[]} GuestArgs
+     * @template {any[]} HostArgs
+     * @param {string} durableName - the orchestration flow identity in the zone
+     *   (to resume across upgrades)
+     * @param {HostContext} hostCtx - values to pass through the async flow
+     *   membrane
+     * @param {(
+     *   guestOrc: Orchestrator,
+     *   guestCtx: GuestContext,
+     *   ...args: GuestArgs
+     * ) => Promise<GuestReturn>} guestFn
+     * @returns {(...args: HostArgs) => Promise<HostReturn>} TODO returns a
+     *   Promise for now for compat before use of asyncFlow. But really should
+     *   be `Vow<HostReturn>`
+     */
+    orchestrate<GuestReturn, HostReturn, GuestContext, HostContext, GuestArgs extends any[], HostArgs extends any[]>(durableName: string, hostCtx: HostContext, guestFn: (guestOrc: Orchestrator, guestCtx: GuestContext, ...args: GuestArgs) => Promise<GuestReturn>): (...args: HostArgs) => Promise<HostReturn>;
+    adminAsyncFlow: import("@endo/exo").Guarded<{
+        getFailures(): import("@endo/patterns").CopyMap<any, import("@endo/pass-style").Passable>;
+        wakeAll(): void;
+        getFlowForOutcomeVow(outcomeVow: any): any;
+    }>;
+};
+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 { 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

@@ -0,0 +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"}

package/src/facade.js

@@ -0,0 +1,132 @@
+/** @file Orchestration service */
+
+import { Fail } from '@agoric/assert';
+import { pickFacet } from '@agoric/vat-data';
+import { prepareOrchestratorKit } from './exos/orchestrator.js';
+
+/**
+ * @import {AsyncFlowTools} from '@agoric/async-flow';
+ * @import {Zone} from '@agoric/zone';
+ * @import {Vow, VowTools} from '@agoric/vow';
+ * @import {TimerService} from '@agoric/time';
+ * @import {IBCConnectionID} from '@agoric/vats';
+ * @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 {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';
+ * @import {MakeLocalOrchestrationAccountKit} from './exos/local-orchestration-account.js';
+ */
+
+/**
+ * @param {{
+ *   zone: Zone;
+ *   timerService: Remote<TimerService>;
+ *   zcf: ZCF;
+ *   storageNode: Remote<StorageNode>;
+ *   orchestrationService: Remote<OrchestrationService>;
+ *   localchain: Remote<LocalChain>;
+ *   chainHub: import('./exos/chain-hub.js').ChainHub;
+ *   makeLocalOrchestrationAccountKit: MakeLocalOrchestrationAccountKit;
+ *   makeRecorderKit: MakeRecorderKit;
+ *   makeCosmosOrchestrationAccount: any;
+ *   makeLocalChainFacade: MakeLocalChainFacade;
+ *   makeRemoteChainFacade: MakeRemoteChainFacade;
+ *   vowTools: VowTools;
+ *   asyncFlowTools: AsyncFlowTools;
+ * }} powers
+ */
+export const makeOrchestrationFacade = ({
+  zone,
+  timerService,
+  zcf,
+  storageNode,
+  orchestrationService,
+  localchain,
+  chainHub,
+  makeLocalOrchestrationAccountKit,
+  makeRecorderKit,
+  makeLocalChainFacade,
+  makeRemoteChainFacade,
+  vowTools,
+  asyncFlowTools,
+}) => {
+  (zone &&
+    timerService &&
+    zcf &&
+    storageNode &&
+    orchestrationService &&
+    // @ts-expect-error type says defined but double check
+    makeLocalOrchestrationAccountKit &&
+    // @ts-expect-error type says defined but double check
+    makeRecorderKit &&
+    // @ts-expect-error type says defined but double check
+    makeRemoteChainFacade &&
+    asyncFlowTools) ||
+    Fail`params missing`;
+
+  const makeOrchestratorKit = prepareOrchestratorKit(zone, {
+    asyncFlowTools,
+    chainHub,
+    localchain,
+    makeRecorderKit,
+    makeLocalChainFacade,
+    makeRemoteChainFacade,
+    orchestrationService,
+    storageNode,
+    timerService,
+    vowTools,
+    zcf,
+  });
+  const makeOrchestrator = pickFacet(makeOrchestratorKit, 'orchestrator');
+
+  const { prepareEndowment, asyncFlow, adminAsyncFlow } = asyncFlowTools;
+
+  const { when } = vowTools;
+
+  return {
+    /**
+     * @template GuestReturn
+     * @template HostReturn
+     * @template GuestContext
+     * @template HostContext
+     * @template {any[]} GuestArgs
+     * @template {any[]} HostArgs
+     * @param {string} durableName - the orchestration flow identity in the zone
+     *   (to resume across upgrades)
+     * @param {HostContext} hostCtx - values to pass through the async flow
+     *   membrane
+     * @param {(
+     *   guestOrc: Orchestrator,
+     *   guestCtx: GuestContext,
+     *   ...args: GuestArgs
+     * ) => Promise<GuestReturn>} guestFn
+     * @returns {(...args: HostArgs) => Promise<HostReturn>} TODO returns a
+     *   Promise for now for compat before use of asyncFlow. But really should
+     *   be `Vow<HostReturn>`
+     */
+    orchestrate(durableName, hostCtx, guestFn) {
+      const subZone = zone.subZone(durableName);
+
+      const hostOrc = makeOrchestrator();
+
+      const [wrappedOrc, wrappedCtx] = prepareEndowment(subZone, 'endowments', [
+        hostOrc,
+        hostCtx,
+      ]);
+
+      const hostFn = asyncFlow(subZone, 'asyncFlow', guestFn);
+
+      const orcFn = (...args) =>
+        // TODO remove the `when` after fixing the return type
+        // to `Vow<HostReturn>`
+        when(hostFn(wrappedOrc, wrappedCtx, ...args));
+      return harden(orcFn);
+    },
+    adminAsyncFlow,
+  };
+};
+harden(makeOrchestrationFacade);
+/** @typedef {ReturnType<typeof makeOrchestrationFacade>} OrchestrationFacade */