@agoric/orchestration 0.1.1-dev-a035bbe.0 → 0.1.1-dev-c244e96.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["orchestrator.js"],"names":[],"mappings":"AAgCA,0BAA0B;AAC1B;;;;;GAKG;AAiBI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAwBG,CAAF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAZF,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BA0B6G,MAAM,KAAK,CAAC;6BAA6gB,QAAQ,KAAK,CAAC,mBAA6B,OAAO;6BAAwjB,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;;;;oBAAqjG,CAAC;;;uBAA6lB,EAAE;;;;;wCAA5+H,WAAW,GAAE,QAAS,OAAO,WAAW,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAzCtsD,GAAG;;IAeP,uCAAuC;4CAyB7C,CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DAzBI,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BA0B6G,MAAM,KAAK,CAAC;yBAA6gB,QAAQ,KAAK,CAAC,mBAA6B,OAAO;yBAAwjB,OAAO,KAAK,CAAC;;;uBAA6rB,EAAE;;;;;GAFt+D;0BA7EoB,mBAAmB;yBAGpB,aAAa;uCASwE,aAAa;+BAAb,aAAa;4BAL/F,kBAAkB;iCADI,6CAA6C;kCAF7D,cAAc;2BAQ8D,aAAa"}

package/src/exos/orchestrator.js

@@ -0,0 +1,93 @@
+/** @file ChainAccount exo */
+import { AmountShape } from '@agoric/ertp';
+import { makeTracer } from '@agoric/internal';
+import { V } from '@agoric/vow/vat.js';
+import { M } from '@endo/patterns';
+import {
+  ChainInfoShape,
+  LocalChainAccountShape,
+  DenomShape,
+  BrandInfoShape,
+  DenomAmountShape,
+} from '../typeGuards.js';
+
+/**
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {ChainHub} from '../utils/chainHub.js';
+ * @import {AsyncFlowTools} from '@agoric/async-flow';
+ * @import {Vow} 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 {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} from '../types.js';
+ */
+
+const { Fail } = assert;
+const trace = makeTracer('Orchestrator');
+
+/** @see {Orchestrator} */
+export const OrchestratorI = M.interface('Orchestrator', {
+  getChain: M.callWhen(M.string()).returns(ChainInfoShape),
+  makeLocalAccount: M.callWhen().returns(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>;
+ *   zcf: ZCF;
+ * }} powers
+ */
+export const prepareOrchestrator = (
+  zone,
+  { chainHub, localchain, makeLocalChainFacade, makeRemoteChainFacade },
+) =>
+  zone.exoClass(
+    'Orchestrator',
+    OrchestratorI,
+    () => {
+      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
+          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);
+      },
+      makeLocalAccount() {
+        return V(localchain).makeAccount();
+      },
+      getBrandInfo: () => Fail`not yet implemented`,
+      asAmount: () => Fail`not yet implemented`,
+    },
+  );
+harden(prepareOrchestrator);

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

@@ -0,0 +1,84 @@
+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<void, undefined>>;
+                Redelegate(srcValidator: import("../cosmos-api.js").CosmosValidatorAddress, dstValidator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): Promise<Invitation<void, 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<void, 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<void>;
+        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<void>;
+        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<void>;
+    }>;
+    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>;
+    timer: Remote<TimerService>;
+}): (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;
+    }>>;
+    /** @returns {Promise<OrchestrationAccount<ChainInfo>>} */
+    makeAccount(): Promise<import("../orchestration-api.js").OrchestrationAccountI>;
+}>;
+export type MakeRemoteChainFacade = ReturnType<typeof prepareRemoteChainFacade>;
+import type { Zone } from '@agoric/base-zone';
+import type { Remote } from '@agoric/internal';
+import type { TimerService } from '@agoric/time';
+import type { IBCConnectionInfo } from '../types.js';
+//# 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":"AAgCO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsBD,0DAA0D;;GAwB7D;oCAEW,UAAU,CAAC,OAAO,wBAAwB,CAAC;0BAzElC,mBAAmB;4BAEjB,kBAAkB;kCADZ,cAAc;uCAIyC,aAAa"}

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

@@ -0,0 +1,81 @@
+/** @file ChainAccount exo */
+import { makeTracer } from '@agoric/internal';
+import { V } from '@agoric/vow/vat.js';
+
+import { ChainFacadeI } from '../typeGuards.js';
+
+/**
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {TimerService} from '@agoric/time';
+ * @import {Remote} from '@agoric/internal';
+ * @import {OrchestrationService} from '../service.js';
+ * @import {prepareCosmosOrchestrationAccount} from './cosmos-orchestration-account.js';
+ * @import {ChainInfo, CosmosChainInfo, IBCConnectionInfo, OrchestrationAccount} from '../types.js';
+ */
+
+const { Fail } = assert;
+const trace = makeTracer('RemoteChainFacade');
+
+/** @type {any} */
+const anyVal = null;
+
+/**
+ * @param {Zone} zone
+ * @param {{
+ *   makeCosmosOrchestrationAccount: ReturnType<
+ *     typeof prepareCosmosOrchestrationAccount
+ *   >;
+ *   orchestration: Remote<OrchestrationService>;
+ *   storageNode: Remote<StorageNode>;
+ *   timer: Remote<TimerService>;
+ * }} powers
+ */
+export const prepareRemoteChainFacade = (
+  zone,
+  { makeCosmosOrchestrationAccount, orchestration, storageNode, timer },
+) =>
+  zone.exoClass(
+    'RemoteChainFacade',
+    ChainFacadeI,
+    /**
+     * @param {CosmosChainInfo} remoteChainInfo
+     * @param {IBCConnectionInfo} connectionInfo
+     */
+    (remoteChainInfo, connectionInfo) => {
+      trace('making an RemoteChainFacade');
+      return { remoteChainInfo, connectionInfo };
+    },
+    {
+      async getChainInfo() {
+        return this.state.remoteChainInfo;
+      },
+
+      // FIXME parameterize on the remoteChainInfo to make()
+      // That used to work but got lost in the migration to Exo
+      /** @returns {Promise<OrchestrationAccount<ChainInfo>>} */
+      async makeAccount() {
+        const { remoteChainInfo, connectionInfo } = this.state;
+
+        const icaAccount = await V(orchestration).makeAccount(
+          remoteChainInfo.chainId,
+          connectionInfo.id,
+          connectionInfo.counterparty.connection_id,
+        );
+
+        const address = await V(icaAccount).getAddress();
+
+        const stakingDenom = remoteChainInfo.stakingTokens?.[0]?.denom;
+        if (!stakingDenom) {
+          throw Fail`chain info lacks staking denom`;
+        }
+        return makeCosmosOrchestrationAccount(address, stakingDenom, {
+          account: icaAccount,
+          storageNode,
+          icqConnection: anyVal,
+          timer,
+        });
+      },
+    },
+  );
+harden(prepareRemoteChainFacade);
+/** @typedef {ReturnType<typeof prepareRemoteChainFacade>} MakeRemoteChainFacade */

package/src/facade.d.ts

@@ -1,4 +1,4 @@
-export function makeOrchestrationFacade({ zone, timerService, zcf, storageNode, orchestrationService, localchain, chainHub, makeLocalChainAccountKit, makeRecorderKit, asyncFlowTools, }: {
+export function makeOrchestrationFacade({ zone, timerService, zcf, storageNode, orchestrationService, localchain, chainHub, makeLocalOrchestrationAccountKit, makeRecorderKit, makeLocalChainFacade, makeRemoteChainFacade, asyncFlowTools, }: {
     zone: Zone;
     timerService: Remote<TimerService>;
     zcf: ZCF;
@@ -35,8 +35,90 @@ export function makeOrchestrationFacade({ zone, timerService, zcf, storageNode,
         }>; }>;
     }>>;
     chainHub: import("./utils/chainHub.js").ChainHub;
-    makeLocalChainAccountKit: ReturnType<typeof import("./exos/local-chain-account-kit.js").prepareLocalChainAccountKit>;
+    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<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/tx.js").MsgDelegateResponse & {
+                '@type': "/cosmos.staking.v1beta1.MsgDelegateResponse";
+            }>, undefined>>;
+            Undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<void, undefined>>;
+            CloseAccount(): never;
+        };
+        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<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/tx.js").MsgDelegateResponse & {
+                '@type': "/cosmos.staking.v1beta1.MsgDelegateResponse";
+            }>>;
+            undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<void>;
+            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>;
+    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;
@@ -45,8 +127,8 @@ export function makeOrchestrationFacade({ zone, timerService, zcf, storageNode,
                 getFlowState(): import("../../../node_modules/@agoric/async-flow/src/types.js").FlowState;
                 restart(eager?: boolean | undefined): void;
                 wake(): void;
-                getOutcome(): import("@agoric/vow").Vow<any>;
-                dump(): ([op: "doFulfill", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, fulfillment: import("@endo/pass-style").Passable] | [op: "doReject", vow: import("@agoric/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])[];
+                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: {
@@ -86,5 +168,7 @@ import type { Zone } from '@agoric/zone';
 import type { TimerService } from '@agoric/time';
 import type { Remote } from '@agoric/internal';
 import type { RecorderKit } from '@agoric/zoe/src/contractSupport/recorder.js';
+import type { IBCConnectionInfo } from './types.js';
+import type { Vow } from '@agoric/vow';
 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":"AAmKO;;;SAZG,GAAG;;;;;;;;;;;;;8BAjDQ,MAAM,KAAK,CAAC;6BAoBrB,QAAO,KAAK,CAAC,mBAA6B,OACtD;6BAoBI,OACF,KACD,CAAC;;;2BA4BI,EAAE;;;;;;;oBAiE4nC,CAAC;;;uBAA6lB,EAAE;;;;;cAnFrtD,OAAO,qBAAqB,EAAE,QAAQ;8BACtB,UAAU,CACxC,cAAoB,mCAAmC,EAAE,2BAA2B,CAC/E;wCAD+B,WAAW,GAAE,QAAS,OAAO,WAAW,EAAE,MAAM,CACpF,WACE,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA6BD;;;;;;;;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;EAwCnD;kCAEa,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BArOjC,cAAc;kCACN,cAAc;4BAIpB,kBAAkB;iCADI,6CAA6C;kCAGe,YAAY"}
+{"version":3,"file":"facade.d.ts","sourceRoot":"","sources":["facade.js"],"names":[],"mappings":"AAuCO;;;SAbG,GAAG;;;;;;;;;;;;;8BAyEiH,MAAM,KAAK,CAAC;6BAA6gB,QAAQ,KAAK,CAAC,mBAA6B,OAAO;6BAAwjB,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;;;;oBAAqjG,CAAC;;;uBAA6lB,EAAE;;;;;cArEnlL,OAAO,qBAAqB,EAAE,QAAQ;;;;8BAqEyE,MAAM,KAAK,CAAC;6BAA6gB,QAAQ,KAAK,CAAC,mBAA6B,OAAO;6BAAwjB,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;;;;2DAAxlD,OAAO,KAAK,CAAC;;;6DAAid,OAAO,KAAK,CAAC;;;;8BAA0tB,QAAS;;;;;;;;;2DAAiyB,OAAO,KAAK,CAAC;;;6DAA+yB,OAAO,KAAK,CAAC;;6BAA56D,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;kCAA46B,SAAU,OAAM,WAAY;;;wCAA/xC,WAAW,GAAE,QAAS,OAAO,WAAW,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC;oCAlE/oD,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;iCADI,6CAA6C;uCAGe,YAAY;yBAPjG,aAAa;kCAOwE,YAAY"}

package/src/facade.js

@@ -1,12 +1,13 @@
 /** @file Orchestration service */
 
-import { V as E } from '@agoric/vow/vat.js';
 import { Fail } from '@agoric/assert';
-import { prepareCosmosOrchestrationAccount } from './exos/cosmosOrchestrationAccount.js';
+
+import { prepareOrchestrator } from './exos/orchestrator.js';
 
 /**
  * @import {AsyncFlowTools} from '@agoric/async-flow';
  * @import {Zone} from '@agoric/zone';
+ * @import {Vow} from '@agoric/vow';
  * @import {TimerService} from '@agoric/time';
  * @import {IBCConnectionID} from '@agoric/vats';
  * @import {LocalChain} from '@agoric/vats/src/localchain.js';
@@ -14,137 +15,11 @@ import { prepareCosmosOrchestrationAccount } from './exos/cosmosOrchestrationAcc
  * @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';
  */
 
-/** @type {any} */
-const anyVal = null;
-
-/**
- * @param {Remote<LocalChain>} localchain
- * @param {ReturnType<
- *   typeof import('./exos/local-chain-account-kit.js').prepareLocalChainAccountKit
- * >} makeLocalChainAccountKit
- * @param {ChainInfo} localInfo
- * @returns {Chain}
- */
-const makeLocalChainFacade = (
-  localchain,
-  makeLocalChainAccountKit,
-  localInfo,
-) => {
-  return {
-    /** @returns {Promise<ChainInfo>} */
-    async getChainInfo() {
-      return localInfo;
-    },
-
-    async makeAccount() {
-      const lcaP = E(localchain).makeAccount();
-      const [lca, address] = await Promise.all([lcaP, E(lcaP).getAddress()]);
-      const { holder: account } = makeLocalChainAccountKit({
-        account: lca,
-        address,
-        // @ts-expect-error TODO: Remote
-        storageNode: null,
-      });
-
-      return {
-        async deposit(payment) {
-          console.log('deposit got', payment);
-          await E(account).deposit(payment);
-        },
-        getAddress() {
-          const addressStr = account.getAddress();
-          return {
-            address: addressStr,
-            chainId: localInfo.chainId,
-            addressEncoding: 'bech32',
-          };
-        },
-        async 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'];
-
-          const natAmount = await E(lca).getBalance(brand);
-          return harden({ denom, value: natAmount.value });
-        },
-        getBalances() {
-          throw new Error('not yet implemented');
-        },
-        async send(toAccount, amount) {
-          // FIXME implement
-          console.log('send got', toAccount, amount);
-        },
-        async transfer(amount, destination, opts) {
-          console.log('transfer got', amount, destination, opts);
-          return account.transfer(amount, destination, opts);
-        },
-        transferSteps(amount, msg) {
-          console.log('transferSteps got', amount, msg);
-          return Promise.resolve();
-        },
-      };
-    },
-  };
-};
-
-/**
- * @template {CosmosChainInfo} CCI
- * @param {CCI} chainInfo
- * @param {IBCConnectionInfo} connectionInfo
- * @param {object} io
- * @param {Remote<OrchestrationService>} io.orchestration
- * @param {MakeRecorderKit} io.makeRecorderKit
- * @param {Remote<StorageNode>} io.storageNode
- * @param {Remote<TimerService>} io.timer
- * @param {ZCF} io.zcf
- * @param {Zone} io.zone
- * @returns {Chain<CCI>}
- */
-const makeRemoteChainFacade = (
-  chainInfo,
-  connectionInfo,
-  { orchestration, makeRecorderKit, storageNode, timer, zcf, zone },
-) => {
-  const makeCosmosOrchestrationAccount = prepareCosmosOrchestrationAccount(
-    zone.subZone(chainInfo.chainId),
-    makeRecorderKit,
-    zcf,
-  );
-
-  return {
-    getChainInfo: async () => chainInfo,
-    /** @returns {Promise<OrchestrationAccount<CCI>>} */
-    makeAccount: async () => {
-      const icaAccount = await E(orchestration).makeAccount(
-        chainInfo.chainId,
-        connectionInfo.id,
-        connectionInfo.counterparty.connection_id,
-      );
-
-      const address = await E(icaAccount).getAddress();
-
-      const [{ denom: bondDenom }] = chainInfo.stakingTokens || [
-        {
-          denom: null,
-        },
-      ];
-      assert(bondDenom, 'missing bondDenom');
-      // @ts-expect-error XXX dynamic method availability
-      return makeCosmosOrchestrationAccount(address, bondDenom, {
-        account: icaAccount,
-        storageNode,
-        icqConnection: anyVal,
-        timer,
-      });
-    },
-  };
-};
-
 /**
  * @param {{
  *   zone: Zone;
@@ -154,10 +29,11 @@ const makeRemoteChainFacade = (
  *   orchestrationService: Remote<OrchestrationService>;
  *   localchain: Remote<LocalChain>;
  *   chainHub: import('./utils/chainHub.js').ChainHub;
- *   makeLocalChainAccountKit: ReturnType<
- *     typeof import('./exos/local-chain-account-kit.js').prepareLocalChainAccountKit
- *   >;
+ *   makeLocalOrchestrationAccountKit: MakeLocalOrchestrationAccountKit;
  *   makeRecorderKit: MakeRecorderKit;
+ *   makeCosmosOrchestrationAccount: any;
+ *   makeLocalChainFacade: MakeLocalChainFacade;
+ *   makeRemoteChainFacade: MakeRemoteChainFacade;
  *   asyncFlowTools: AsyncFlowTools;
  * }} powers
  */
@@ -169,8 +45,10 @@ export const makeOrchestrationFacade = ({
   orchestrationService,
   localchain,
   chainHub,
-  makeLocalChainAccountKit,
+  makeLocalOrchestrationAccountKit,
   makeRecorderKit,
+  makeLocalChainFacade,
+  makeRemoteChainFacade,
   asyncFlowTools,
 }) => {
   (zone &&
@@ -179,12 +57,27 @@ export const makeOrchestrationFacade = ({
     storageNode &&
     orchestrationService &&
     // @ts-expect-error type says defined but double check
-    makeLocalChainAccountKit &&
+    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 makeOrchestrator = prepareOrchestrator(zone, {
+    asyncFlowTools,
+    chainHub,
+    localchain,
+    makeRecorderKit,
+    makeLocalChainFacade,
+    makeRemoteChainFacade,
+    orchestrationService,
+    storageNode,
+    timerService,
+    zcf,
+  });
+
   return {
     /**
      * @template Context
@@ -196,40 +89,8 @@ export const makeOrchestrationFacade = ({
      * @returns {(...args: Args) => Promise<unknown>}
      */
     orchestrate(durableName, ctx, fn) {
-      /** @type {Orchestrator} */
-      const orc = {
-        async getChain(name) {
-          const agoricChainInfo = await chainHub.getChainInfo('agoric');
-
-          if (name === 'agoric') {
-            return makeLocalChainFacade(
-              localchain,
-              makeLocalChainAccountKit,
-              agoricChainInfo,
-            );
-          }
-
-          const remoteChainInfo = await chainHub.getChainInfo(name);
-          const connectionInfo = await chainHub.getConnectionInfo(
-            agoricChainInfo.chainId,
-            remoteChainInfo.chainId,
-          );
+      const orc = makeOrchestrator();
 
-          return makeRemoteChainFacade(remoteChainInfo, connectionInfo, {
-            orchestration: orchestrationService,
-            makeRecorderKit,
-            storageNode,
-            timer: timerService,
-            zcf,
-            zone,
-          });
-        },
-        makeLocalAccount() {
-          return E(localchain).makeAccount();
-        },
-        getBrandInfo: anyVal,
-        asAmount: anyVal,
-      };
       return async (...args) => fn(orc, ctx, ...args);
     },
   };