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

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

@@ -0,0 +1,446 @@
+/** @file Use-object for the owner of a localchain account */
+import { typedJson } from '@agoric/cosmic-proto/vatsafe';
+import { AmountShape, PaymentShape } from '@agoric/ertp';
+import { makeTracer } from '@agoric/internal';
+import { Shape as NetworkShape } from '@agoric/network';
+import { M } from '@agoric/vat-data';
+import { VowShape } from '@agoric/vow';
+import { TopicsRecordShape } from '@agoric/zoe/src/contractSupport/index.js';
+import { E } from '@endo/far';
+import {
+  ChainAddressShape,
+  ChainAmountShape,
+  DenomAmountShape,
+  DenomShape,
+  IBCTransferOptionsShape,
+} from '../typeGuards.js';
+import { maxClockSkew } from '../utils/cosmos.js';
+import { orchestrationAccountMethods } from '../utils/orchestrationAccount.js';
+import { dateInSeconds, makeTimestampHelper } from '../utils/time.js';
+
+/**
+ * @import {LocalChainAccount} from '@agoric/vats/src/localchain.js';
+ * @import {AmountArg, ChainAddress, DenomAmount, IBCMsgTransferOptions, OrchestrationAccount, ChainInfo, IBCConnectionInfo, PromiseToVow} from '@agoric/orchestration';
+ * @import {RecorderKit, MakeRecorderKit} from '@agoric/zoe/src/contractSupport/recorder.js'.
+ * @import {Zone} from '@agoric/zone';
+ * @import {Remote} from '@agoric/internal';
+ * @import {TimerService, TimerBrand, TimestampRecord} from '@agoric/time';
+ * @import {PromiseVow, Vow, VowTools} from '@agoric/vow';
+ * @import {TypedJson, JsonSafe} from '@agoric/cosmic-proto';
+ * @import {ChainHub} from './chain-hub.js';
+ */
+
+const trace = makeTracer('LOA');
+
+const { Fail } = assert;
+const { Vow$ } = NetworkShape; // TODO #9611
+
+/**
+ * @typedef {object} LocalChainAccountNotification
+ * @property {string} address
+ */
+
+/**
+ * @typedef {{
+ *   topicKit: RecorderKit<LocalChainAccountNotification>;
+ *   account: LocalChainAccount;
+ *   address: ChainAddress;
+ * }} State
+ */
+
+const HolderI = M.interface('holder', {
+  ...orchestrationAccountMethods,
+  getPublicTopics: M.call().returns(TopicsRecordShape),
+  delegate: M.call(M.string(), AmountShape).returns(VowShape),
+  undelegate: M.call(M.string(), AmountShape).returns(VowShape),
+  withdraw: M.call(AmountShape).returns(Vow$(PaymentShape)),
+  executeTx: M.call(M.arrayOf(M.record())).returns(Vow$(M.record())),
+});
+
+/** @type {{ [name: string]: [description: string, valueShape: Pattern] }} */
+const PUBLIC_TOPICS = {
+  account: ['Account holder status', M.any()],
+};
+
+/**
+ * @param {Zone} zone
+ * @param {MakeRecorderKit} makeRecorderKit
+ * @param {ZCF} zcf
+ * @param {Remote<TimerService>} timerService
+ * @param {VowTools} vowTools
+ * @param {ChainHub} chainHub
+ */
+export const prepareLocalOrchestrationAccountKit = (
+  zone,
+  makeRecorderKit,
+  zcf,
+  timerService,
+  { watch, allVows, asVow },
+  chainHub,
+) => {
+  const timestampHelper = makeTimestampHelper(timerService);
+
+  /** Make an object wrapping an LCA with Zoe interfaces. */
+  const makeLocalOrchestrationAccountKit = zone.exoClassKit(
+    'Local Orchestration Account Kit',
+    {
+      holder: HolderI,
+      undelegateWatcher: M.interface('undelegateWatcher', {
+        onFulfilled: M.call([M.splitRecord({ completionTime: M.string() })])
+          .optional(M.arrayOf(M.undefined())) // empty context
+          .returns(VowShape),
+      }),
+      getChainInfoWatcher: M.interface('getChainInfoWatcher', {
+        onFulfilled: M.call(M.record()) // agoric chain info
+          .optional(ChainAddressShape)
+          .returns(Vow$(M.record())), // connection info
+      }),
+      transferWatcher: M.interface('transferWatcher', {
+        onFulfilled: M.call([M.record(), M.nat()])
+          .optional({
+            destination: ChainAddressShape,
+            opts: M.or(M.undefined(), IBCTransferOptionsShape),
+            amount: ChainAmountShape,
+          })
+          .returns(Vow$(M.record())),
+      }),
+      extractFirstResultWatcher: M.interface('extractFirstResultWatcher', {
+        onFulfilled: M.call([M.record()])
+          .optional(M.arrayOf(M.undefined()))
+          .returns(M.any()),
+      }),
+      returnVoidWatcher: M.interface('returnVoidWatcher', {
+        onFulfilled: M.call(M.any())
+          .optional(M.arrayOf(M.undefined()))
+          .returns(M.undefined()),
+      }),
+      getBalanceWatcher: M.interface('getBalanceWatcher', {
+        onFulfilled: M.call(AmountShape)
+          .optional(DenomShape)
+          .returns(DenomAmountShape),
+      }),
+      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()),
+      }),
+    },
+    /**
+     * @param {object} initState
+     * @param {LocalChainAccount} initState.account
+     * @param {ChainAddress} initState.address
+     * @param {Remote<StorageNode>} initState.storageNode
+     * @returns {State}
+     */
+    ({ account, address, storageNode }) => {
+      // must be the fully synchronous maker because the kit is held in durable state
+      // @ts-expect-error XXX Patterns
+      const topicKit = makeRecorderKit(storageNode, PUBLIC_TOPICS.account[1]);
+
+      return { account, address, topicKit };
+    },
+    {
+      invitationMakers: {
+        /**
+         * @param {string} validatorAddress
+         * @param {Amount<'nat'>} ertpAmount
+         */
+        Delegate(validatorAddress, ertpAmount) {
+          trace('Delegate', validatorAddress, ertpAmount);
+
+          return zcf.makeInvitation(seat => {
+            seat.exit();
+            return watch(
+              this.facets.holder.delegate(validatorAddress, ertpAmount),
+            );
+          }, 'Delegate');
+        },
+        /**
+         * @param {string} validatorAddress
+         * @param {Amount<'nat'>} ertpAmount
+         */
+        Undelegate(validatorAddress, ertpAmount) {
+          trace('Undelegate', validatorAddress, ertpAmount);
+
+          return zcf.makeInvitation(seat => {
+            seat.exit();
+            return watch(
+              this.facets.holder.undelegate(validatorAddress, ertpAmount),
+            );
+          }, 'Undelegate');
+        },
+        CloseAccount() {
+          throw Error('not yet implemented');
+        },
+      },
+      undelegateWatcher: {
+        /**
+         * @param {[
+         *   JsonSafe<
+         *     TypedJson<'/cosmos.staking.v1beta1.MsgUndelegateResponse'>
+         *   >,
+         * ]} response
+         */
+        onFulfilled(response) {
+          const { completionTime } = response[0];
+          return watch(
+            E(timerService).wakeAt(
+              // TODO clean up date handling once we have real data
+              dateInSeconds(new Date(completionTime)) + maxClockSkew,
+            ),
+          );
+        },
+      },
+      getChainInfoWatcher: {
+        /**
+         * @param {ChainInfo} agoricChainInfo
+         * @param {ChainAddress} destination
+         */
+        onFulfilled(agoricChainInfo, destination) {
+          return chainHub.getConnectionInfo(
+            agoricChainInfo.chainId,
+            destination.chainId,
+          );
+        },
+      },
+      transferWatcher: {
+        /**
+         * @param {[
+         *   { transferChannel: IBCConnectionInfo['transferChannel'] },
+         *   bigint,
+         * ]} results
+         * @param {{
+         *   destination: ChainAddress;
+         *   opts: IBCMsgTransferOptions;
+         *   amount: DenomAmount;
+         * }} ctx
+         */
+        onFulfilled(
+          [{ transferChannel }, timeoutTimestamp],
+          { opts, amount, destination },
+        ) {
+          return watch(
+            E(this.state.account).executeTx([
+              typedJson('/ibc.applications.transfer.v1.MsgTransfer', {
+                sourcePort: transferChannel.portId,
+                sourceChannel: transferChannel.channelId,
+                token: {
+                  amount: String(amount.value),
+                  denom: amount.denom,
+                },
+                sender: this.state.address.address,
+                receiver: destination.address,
+                timeoutHeight: opts?.timeoutHeight ?? {
+                  revisionHeight: 0n,
+                  revisionNumber: 0n,
+                },
+                timeoutTimestamp,
+                memo: opts?.memo ?? '',
+              }),
+            ]),
+          );
+        },
+      },
+      /**
+       * takes an array of results (from `executeEncodedTx`) and returns the
+       * first result
+       */
+      extractFirstResultWatcher: {
+        /**
+         * @param {Record<unknown, unknown>[]} results
+         */
+        onFulfilled(results) {
+          results.length === 1 ||
+            Fail`expected exactly one result; got ${results}`;
+          return results[0];
+        },
+      },
+      /**
+       * takes an array of results (from `executeEncodedTx`) and returns void
+       * since we are not interested in the result
+       */
+      returnVoidWatcher: {
+        /**
+         * @param {unknown} _result
+         */
+        onFulfilled(_result) {
+          return undefined;
+        },
+      },
+      /**
+       * handles a request for balance from a bank purse and returns the balance
+       * as a Chain Amount
+       */
+      getBalanceWatcher: {
+        /**
+         * @param {Amount<'nat'>} natAmount
+         * @param {DenomAmount['denom']} denom
+         * @returns {DenomAmount}
+         */
+        onFulfilled(natAmount, denom) {
+          return harden({ denom, value: natAmount.value });
+        },
+      },
+      holder: {
+        /**
+         * TODO: balance lookups for non-vbank assets
+         *
+         * @type {PromiseToVow<OrchestrationAccount<any>['getBalance']>}
+         */
+        getBalance(denomArg) {
+          // FIXME look up real values
+          // UNTIL https://github.com/Agoric/agoric-sdk/issues/9211
+          const [brand, denom] =
+            typeof denomArg === 'string'
+              ? [/** @type {any} */ (null), denomArg]
+              : [denomArg, 'FIXME'];
+
+          return watch(
+            E(this.state.account).getBalance(brand),
+            this.facets.getBalanceWatcher,
+            denom,
+          );
+        },
+        getBalances() {
+          // TODO https://github.com/Agoric/agoric-sdk/issues/9610
+          return asVow(() => Fail`not yet implemented`);
+        },
+
+        getPublicTopics() {
+          const { topicKit } = this.state;
+          return harden({
+            account: {
+              description: PUBLIC_TOPICS.account[0],
+              subscriber: topicKit.subscriber,
+              storagePath: topicKit.recorder.getStoragePath(),
+            },
+          });
+        },
+        /**
+         * @param {string} validatorAddress
+         * @param {Amount<'nat'>} ertpAmount
+         */
+        delegate(validatorAddress, ertpAmount) {
+          // TODO #9211 lookup denom from brand
+          const amount = {
+            amount: String(ertpAmount.value),
+            denom: 'ubld',
+          };
+          const { account: lca } = this.state;
+
+          return watch(
+            E(lca).executeTx([
+              typedJson('/cosmos.staking.v1beta1.MsgDelegate', {
+                amount,
+                validatorAddress,
+                delegatorAddress: this.state.address.address,
+              }),
+            ]),
+            this.facets.extractFirstResultWatcher,
+          );
+        },
+        /**
+         * @param {string} validatorAddress
+         * @param {Amount<'nat'>} ertpAmount
+         * @returns {Vow<void | TimestampRecord>}
+         */
+        undelegate(validatorAddress, ertpAmount) {
+          // TODO #9211 lookup denom from brand
+          const amount = {
+            amount: String(ertpAmount.value),
+            denom: 'ubld',
+          };
+          const { account: lca } = this.state;
+          return watch(
+            E(lca).executeTx([
+              typedJson('/cosmos.staking.v1beta1.MsgUndelegate', {
+                amount,
+                validatorAddress,
+                delegatorAddress: this.state.address.address,
+              }),
+            ]),
+            this.facets.undelegateWatcher,
+          );
+        },
+        /**
+         * Starting a transfer revokes the account holder. The associated
+         * updater will get a special notification that the account is being
+         * transferred.
+         */
+        /** @type {PromiseToVow<OrchestrationAccount<any>['deposit']>} */
+        deposit(payment) {
+          return watch(
+            E(this.state.account).deposit(payment),
+            this.facets.returnVoidWatcher,
+          );
+        },
+        /** @type {PromiseToVow<LocalChainAccount['withdraw']>} */
+        withdraw(amount) {
+          return watch(E(this.state.account).withdraw(amount));
+        },
+        /** @type {PromiseToVow<LocalChainAccount['executeTx']>} */
+        executeTx(messages) {
+          return watch(E(this.state.account).executeTx(messages));
+        },
+        /** @type {OrchestrationAccount<any>['getAddress']} */
+        getAddress() {
+          return this.state.address;
+        },
+        send(toAccount, amount) {
+          return asVow(() => {
+            // FIXME implement
+            console.log('send got', toAccount, amount);
+            throw Fail`send not yet implemented`;
+          });
+        },
+        /**
+         * @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<void>}
+         */
+        transfer(amount, destination, opts) {
+          return asVow(() => {
+            trace('Transferring funds from LCA over IBC');
+            // TODO #9211 lookup denom from brand
+            if ('brand' in amount) throw Fail`ERTP Amounts not yet supported`;
+
+            const connectionInfoV = watch(
+              chainHub.getChainInfo('agoric'),
+              this.facets.getChainInfoWatcher,
+              destination,
+            );
+
+            // set a `timeoutTimestamp` if caller does not supply either `timeoutHeight` or `timeoutTimestamp`
+            // TODO #9324 what's a reasonable default? currently 5 minutes
+            const timeoutTimestampVowOrValue =
+              opts?.timeoutTimestamp ??
+              (opts?.timeoutHeight
+                ? 0n
+                : E(timestampHelper).getTimeoutTimestampNS());
+
+            const transferV = watch(
+              allVows([connectionInfoV, timeoutTimestampVowOrValue]),
+              this.facets.transferWatcher,
+              { opts, amount, destination },
+            );
+            return watch(transferV, this.facets.returnVoidWatcher);
+          });
+        },
+        /** @type {PromiseToVow<OrchestrationAccount<any>['transferSteps']>} */
+        transferSteps(amount, msg) {
+          return asVow(() => {
+            console.log('transferSteps got', amount, msg);
+            throw Fail`not yet implemented`;
+          });
+        },
+      },
+    },
+  );
+  return makeLocalOrchestrationAccountKit;
+};
+/** @typedef {ReturnType<typeof prepareLocalOrchestrationAccountKit>} MakeLocalOrchestrationAccountKit */
+/** @typedef {ReturnType<MakeLocalOrchestrationAccountKit>} LocalOrchestrationAccountKit */

package/src/exos/orchestrator.d.ts

@@ -0,0 +1,91 @@
+/** @see {Orchestrator} */
+export const OrchestratorI: import("@endo/patterns").InterfaceGuard<{
+    getChain: import("@endo/patterns").MethodGuard;
+    makeLocalAccount: import("@endo/patterns").MethodGuard;
+    getBrandInfo: import("@endo/patterns").MethodGuard;
+    asAmount: import("@endo/patterns").MethodGuard;
+}>;
+export function prepareOrchestratorKit(zone: Zone, { chainHub, localchain, makeLocalChainFacade, makeRemoteChainFacade, vowTools: { watch }, }: {
+    asyncFlowTools: AsyncFlowTools;
+    chainHub: ChainHub;
+    localchain: Remote<LocalChain>;
+    makeRecorderKit: MakeRecorderKit;
+    makeLocalChainFacade: MakeLocalChainFacade;
+    makeRemoteChainFacade: MakeRemoteChainFacade;
+    orchestrationService: Remote<OrchestrationService>;
+    storageNode: Remote<StorageNode>;
+    timerService: Remote<TimerService>;
+    vowTools: VowTools;
+    zcf: ZCF;
+}): () => import("@endo/exo").GuardedKit<{
+    /** Waits for `chainInfo` and returns a LocalChainFacade */
+    makeLocalChainFacadeWatcher: {
+        /** @param {ChainInfo} agoricChainInfo */
+        onFulfilled(agoricChainInfo: ChainInfo): import("@endo/exo").Guarded<{
+            getChainInfo(): Vow<Readonly<{
+                chainId: string;
+                connections?: Record<string, IBCConnectionInfo>;
+                icqEnabled?: boolean;
+                stakingTokens?: Readonly<Array<{
+                    denom: string;
+                }>>;
+            }>>;
+            makeAccount(): Vow<PromiseToVow<OrchestrationAccount<ChainInfo>>>;
+        }>;
+    };
+    /**
+     * 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]: [ChainInfo, ChainInfo, IBCConnectionInfo]): import("@endo/exo").Guarded<{
+            getChainInfo(): Vow<Readonly<{
+                chainId: string;
+                connections?: Record<string, IBCConnectionInfo>;
+                icqEnabled?: boolean;
+                stakingTokens?: Readonly<Array<{
+                    denom: string;
+                }>>;
+            }>>;
+            makeAccount(): Vow<PromiseToVow<OrchestrationAccount<ChainInfo>>>;
+        }>;
+    };
+    orchestrator: {
+        /** @type {PromiseToVow<Orchestrator['getChain']>} */
+        getChain(chainName: string): Vow<Chain<any>>;
+        makeLocalAccount(): Vow<import("@endo/exo").Guarded<{
+            getAddress(): string;
+            getBalance(brand: Brand<"nat">): import("@agoric/vow").PromiseVow<Amount<"nat">>;
+            deposit(payment: 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>;
+        }>>;
+        getBrandInfo: () => never;
+        asAmount: () => never;
+    };
+}>;
+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 { 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 { TimerService } from '@agoric/time';
+import type { VowTools } from '@agoric/vow';
+import type { ChainInfo } from '../types.js';
+import type { IBCConnectionInfo } from '../types.js';
+import type { Vow } from '@agoric/vow';
+import type { OrchestrationAccount } from '../types.js';
+import type { PromiseToVow } from '../types.js';
+import type { Chain } from '../types.js';
+//# sourceMappingURL=orchestrator.d.ts.map

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

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

package/src/exos/orchestrator.js

@@ -0,0 +1,141 @@
+/** @file ChainAccount exo */
+import { AmountShape } from '@agoric/ertp';
+import { makeTracer } from '@agoric/internal';
+import { Shape as NetworkShape } from '@agoric/network';
+import { E } from '@endo/far';
+import { M } from '@endo/patterns';
+import {
+  BrandInfoShape,
+  ChainInfoShape,
+  DenomAmountShape,
+  DenomShape,
+  LocalChainAccountShape,
+} from '../typeGuards.js';
+
+/**
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {ChainHub} from './chain-hub.js';
+ * @import {AsyncFlowTools} from '@agoric/async-flow';
+ * @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';
+ * @import {MakeRemoteChainFacade} from './remote-chain-facade.js';
+ * @import {Chain, ChainInfo, CosmosChainInfo, IBCConnectionInfo, OrchestrationAccount, Orchestrator, PromiseToVow} from '../types.js';
+ */
+
+const { Fail } = assert;
+const { Vow$ } = NetworkShape; // TODO #9611
+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)),
+  getBrandInfo: M.call(DenomShape).returns(BrandInfoShape),
+  asAmount: M.call(DenomAmountShape).returns(AmountShape),
+});
+
+/**
+ * @param {Zone} zone
+ * @param {{
+ *   asyncFlowTools: AsyncFlowTools;
+ *   chainHub: ChainHub;
+ *   localchain: Remote<LocalChain>;
+ *   makeRecorderKit: MakeRecorderKit;
+ *   makeLocalChainFacade: MakeLocalChainFacade;
+ *   makeRemoteChainFacade: MakeRemoteChainFacade;
+ *   orchestrationService: Remote<OrchestrationService>;
+ *   storageNode: Remote<StorageNode>;
+ *   timerService: Remote<TimerService>;
+ *   vowTools: VowTools;
+ *   zcf: ZCF;
+ * }} powers
+ */
+export const prepareOrchestratorKit = (
+  zone,
+  {
+    chainHub,
+    localchain,
+    makeLocalChainFacade,
+    makeRemoteChainFacade,
+    vowTools: { watch },
+  },
+) =>
+  zone.exoClassKit(
+    'Orchestrator',
+    {
+      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.any())
+            .optional(M.arrayOf(M.undefined()))
+            .returns(M.any()), // FIXME narrow
+        },
+      ),
+    },
+    () => {
+      trace('making an Orchestrator');
+      return {};
+    },
+    {
+      /** Waits for `chainInfo` and returns a LocalChainFacade */
+      makeLocalChainFacadeWatcher: {
+        /** @param {ChainInfo} agoricChainInfo */
+        onFulfilled(agoricChainInfo) {
+          return makeLocalChainFacade(agoricChainInfo);
+        },
+      },
+      /**
+       * 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);
+        },
+      },
+      orchestrator: {
+        /** @type {PromiseToVow<Orchestrator['getChain']>} */
+        getChain(name) {
+          if (name === 'agoric') {
+            // TODO #9449 fix types
+            // @ts-expect-error Type 'Vow<Voidless>' is not assignable to type 'Vow<Chain<any>>'.
+            return watch(
+              chainHub.getChainInfo('agoric'),
+              this.facets.makeLocalChainFacadeWatcher,
+            );
+          }
+          // TODO #9449 fix types
+          // @ts-expect-error Type 'Vow<Voidless>' is not assignable to type 'Vow<Chain<any>>'.
+          return watch(
+            chainHub.getChainsAndConnection('agoric', name),
+            this.facets.makeRemoteChainFacadeWatcher,
+          );
+        },
+        makeLocalAccount() {
+          return watch(E(localchain).makeAccount());
+        },
+        getBrandInfo: () => Fail`not yet implemented`,
+        asAmount: () => Fail`not yet implemented`,
+      },
+    },
+  );
+harden(prepareOrchestratorKit);