@agoric/orchestration 0.1.1-dev-0006934.0 → 0.1.1-dev-12ce494.0

package/src/proposals/start-basic-flows.js

@@ -0,0 +1,97 @@
+/**
+ * @file A proposal to start the basic flows contract.
+ */
+import { makeTracer } from '@agoric/internal';
+import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
+import { E } from '@endo/far';
+
+/**
+ * @import {BasicFlowsSF} from '../examples/basic-flows.contract.js';
+ */
+
+const trace = makeTracer('StartBasicFlows', true);
+const contractName = 'basicFlows';
+
+/**
+ * See `@agoric/builders/builders/scripts/orchestration/init-basic-flows.js` for
+ * the accompanying proposal builder. Run `agoric run
+ * packages/builders/scripts/orchestration/init-basic-flows.js` to build the
+ * contract and proposal files.
+ *
+ * @param {BootstrapPowers} powers
+ */
+export const startBasicFlows = async ({
+  consume: {
+    agoricNames,
+    board,
+    chainStorage,
+    chainTimerService,
+    cosmosInterchainService,
+    localchain,
+    startUpgradable,
+  },
+  installation: {
+    // @ts-expect-error not a WellKnownName
+    consume: { [contractName]: installation },
+  },
+  instance: {
+    // @ts-expect-error not a WellKnownName
+    produce: { [contractName]: produceInstance },
+  },
+}) => {
+  trace(`start ${contractName}`);
+  await null;
+
+  const storageNode = await makeStorageNodeChild(chainStorage, contractName);
+  const marshaller = await E(board).getPublishingMarshaller();
+
+  /** @type {StartUpgradableOpts<BasicFlowsSF>} */
+  const startOpts = {
+    label: 'basicFlows',
+    installation,
+    terms: undefined,
+    privateArgs: {
+      agoricNames: await agoricNames,
+      orchestrationService: await cosmosInterchainService,
+      localchain: await localchain,
+      storageNode,
+      marshaller,
+      timerService: await chainTimerService,
+    },
+  };
+
+  const { instance } = await E(startUpgradable)(startOpts);
+  produceInstance.resolve(instance);
+};
+harden(startBasicFlows);
+
+export const getManifestForContract = (
+  { restoreRef },
+  { installKeys, ...options },
+) => {
+  return {
+    manifest: {
+      [startBasicFlows.name]: {
+        consume: {
+          agoricNames: true,
+          board: true,
+          chainStorage: true,
+          chainTimerService: true,
+          cosmosInterchainService: true,
+          localchain: true,
+          startUpgradable: true,
+        },
+        installation: {
+          consume: { [contractName]: true },
+        },
+        instance: {
+          produce: { [contractName]: true },
+        },
+      },
+    },
+    installations: {
+      [contractName]: restoreRef(installKeys[contractName]),
+    },
+    options,
+  };
+};

package/src/proposals/start-stakeAtom.d.ts

@@ -9,12 +9,12 @@ export function startStakeAtom({ consume: { agoricNames, board, chainStorage, ch
             }, baggage: import("@agoric/vat-data").Baggage) => Promise<{
                 publicFacet: import("@endo/exo").Guarded<{
                     makeAccount(): Promise<import("@endo/exo").Guarded<{
-                        asContinuingOffer(): {
+                        asContinuingOffer(): import("@agoric/vow").Vow<{
                             publicSubscribers: {
                                 account: {
                                     description: string;
                                     subscriber: globalThis.Subscriber<import("../exos/cosmos-orchestration-account.js").ComosOrchestrationAccountNotification>;
-                                    storagePath: Promise<string>;
+                                    storagePath: string;
                                 };
                             };
                             invitationMakers: import("@endo/exo").Guarded<{
@@ -26,14 +26,14 @@ export function startStakeAtom({ consume: { agoricNames, board, chainStorage, ch
                                 TransferAccount(): never;
                             }>;
                             holder: import("@endo/exo").Guarded<any>;
-                        };
-                        getPublicTopics(): {
+                        }>;
+                        getPublicTopics(): import("@agoric/vow").Vow<{
                             account: {
                                 description: string;
                                 subscriber: globalThis.Subscriber<import("../exos/cosmos-orchestration-account.js").ComosOrchestrationAccountNotification>;
-                                storagePath: Promise<string>;
+                                storagePath: string;
                             };
-                        };
+                        }>;
                         getAddress(): import("../orchestration-api.js").ChainAddress;
                         delegate(validator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): import("@agoric/vow").Vow<undefined>;
                         getBalances(): import("@agoric/vow").Vow<never>;
@@ -46,12 +46,12 @@ export function startStakeAtom({ consume: { agoricNames, board, chainStorage, ch
                         withdrawRewards(): import("@agoric/vow").Vow<never>;
                         undelegate(delegations: Omit<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").Delegation, "delegatorAddress">[]): import("@agoric/vow").Vow<undefined>;
                     }>>;
-                    makeAccountInvitationMaker(): Promise<Invitation<{
+                    makeAccountInvitationMaker(): Promise<Invitation<import("@agoric/vow").Vow<{
                         publicSubscribers: {
                             account: {
                                 description: string;
                                 subscriber: globalThis.Subscriber<import("../exos/cosmos-orchestration-account.js").ComosOrchestrationAccountNotification>;
-                                storagePath: Promise<string>;
+                                storagePath: string;
                             };
                         };
                         invitationMakers: import("@endo/exo").Guarded<{
@@ -63,7 +63,7 @@ export function startStakeAtom({ consume: { agoricNames, board, chainStorage, ch
                             TransferAccount(): never;
                         }>;
                         holder: import("@endo/exo").Guarded<any>;
-                    }, undefined>>;
+                    }>, undefined>>;
                 }>;
             }>>;
         };

package/src/proposals/start-stakeBld.d.ts

@@ -9,12 +9,12 @@ export function startStakeBld({ consume: { agoricNames: agoricNamesP, board, cha
                 timerService: import("@agoric/time").TimerService;
             }, baggage: import("@agoric/vat-data").Baggage) => Promise<{
                 publicFacet: import("@endo/exo").Guarded<{
-                    makeStakeBldInvitation(): Promise<Invitation<{
+                    makeStakeBldInvitation(): Promise<Invitation<import("@agoric/vow").Vow<{
                         publicSubscribers: {
                             account: {
                                 description: string;
                                 subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
-                                storagePath: Promise<string>;
+                                storagePath: string;
                             };
                         };
                         invitationMakers: import("@endo/exo").Guarded<{
@@ -22,16 +22,17 @@ export function startStakeBld({ consume: { agoricNames: agoricNamesP, board, cha
                             Undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<import("@agoric/vow").Vow<import("@agoric/time").TimestampRecord>, undefined>>;
                             CloseAccount(): never;
                         }>;
-                        account: import("@endo/exo").Guarded<{
+                        holder: import("@endo/exo").Guarded<{
+                            asContinuingOffer(): import("@agoric/vow").Vow<any>;
                             getBalance(denom: import("../orchestration-api.js").DenomArg): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount>;
                             getBalances(): import("@agoric/vow").Vow<never>;
-                            getPublicTopics(): {
+                            getPublicTopics(): import("@agoric/vow").Vow<{
                                 account: {
                                     description: string;
                                     subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
-                                    storagePath: Promise<string>;
+                                    storagePath: string;
                                 };
-                            };
+                            }>;
                             delegate(validatorAddress: string, ertpAmount: Amount<"nat">): import("@agoric/vow").Vow<Record<unknown, unknown>>;
                             undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): import("@agoric/vow").Vow<void | import("@agoric/time").TimestampRecord>;
                             deposit(payment: globalThis.Payment<"nat">, optAmountShape?: globalThis.Pattern): import("@agoric/vow").Vow<import("@agoric/ertp/src/types.js").NatAmount | import("@agoric/vow").Vow<import("@agoric/ertp/src/types.js").NatAmount>>;
@@ -46,17 +47,18 @@ export function startStakeBld({ consume: { agoricNames: agoricNamesP, board, cha
                             transfer(amount: import("../orchestration-api.js").AmountArg, destination: import("../orchestration-api.js").ChainAddress, opts?: import("../cosmos-api.js").IBCMsgTransferOptions | undefined): import("@agoric/vow").Vow<void>;
                             transferSteps(amount: import("../orchestration-api.js").AmountArg, msg: import("../orchestration-api.js").TransferMsg): import("@agoric/vow").Vow<void>;
                         }>;
-                    }, undefined>>;
+                    }>, undefined>>;
                     makeAccount(): Promise<import("@endo/exo").Guarded<{
+                        asContinuingOffer(): import("@agoric/vow").Vow<any>;
                         getBalance(denom: import("../orchestration-api.js").DenomArg): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount>;
                         getBalances(): import("@agoric/vow").Vow<never>;
-                        getPublicTopics(): {
+                        getPublicTopics(): import("@agoric/vow").Vow<{
                             account: {
                                 description: string;
                                 subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
-                                storagePath: Promise<string>;
+                                storagePath: string;
                             };
-                        };
+                        }>;
                         delegate(validatorAddress: string, ertpAmount: Amount<"nat">): import("@agoric/vow").Vow<Record<unknown, unknown>>;
                         undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): import("@agoric/vow").Vow<void | import("@agoric/time").TimestampRecord>;
                         deposit(payment: globalThis.Payment<"nat">, optAmountShape?: globalThis.Pattern): import("@agoric/vow").Vow<import("@agoric/ertp/src/types.js").NatAmount | import("@agoric/vow").Vow<import("@agoric/ertp/src/types.js").NatAmount>>;
@@ -71,12 +73,12 @@ export function startStakeBld({ consume: { agoricNames: agoricNamesP, board, cha
                         transfer(amount: import("../orchestration-api.js").AmountArg, destination: import("../orchestration-api.js").ChainAddress, opts?: import("../cosmos-api.js").IBCMsgTransferOptions | undefined): import("@agoric/vow").Vow<void>;
                         transferSteps(amount: import("../orchestration-api.js").AmountArg, msg: import("../orchestration-api.js").TransferMsg): import("@agoric/vow").Vow<void>;
                     }>>;
-                    makeAccountInvitationMaker(): Promise<Invitation<{
+                    makeAccountInvitationMaker(): Promise<Invitation<import("@agoric/vow").Vow<{
                         publicSubscribers: {
                             account: {
                                 description: string;
                                 subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
-                                storagePath: Promise<string>;
+                                storagePath: string;
                             };
                         };
                         invitationMakers: import("@endo/exo").Guarded<{
@@ -84,16 +86,17 @@ export function startStakeBld({ consume: { agoricNames: agoricNamesP, board, cha
                             Undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<import("@agoric/vow").Vow<import("@agoric/time").TimestampRecord>, undefined>>;
                             CloseAccount(): never;
                         }>;
-                        account: import("@endo/exo").Guarded<{
+                        holder: import("@endo/exo").Guarded<{
+                            asContinuingOffer(): import("@agoric/vow").Vow<any>;
                             getBalance(denom: import("../orchestration-api.js").DenomArg): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount>;
                             getBalances(): import("@agoric/vow").Vow<never>;
-                            getPublicTopics(): {
+                            getPublicTopics(): import("@agoric/vow").Vow<{
                                 account: {
                                     description: string;
                                     subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
-                                    storagePath: Promise<string>;
+                                    storagePath: string;
                                 };
-                            };
+                            }>;
                             delegate(validatorAddress: string, ertpAmount: Amount<"nat">): import("@agoric/vow").Vow<Record<unknown, unknown>>;
                             undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): import("@agoric/vow").Vow<void | import("@agoric/time").TimestampRecord>;
                             deposit(payment: globalThis.Payment<"nat">, optAmountShape?: globalThis.Pattern): import("@agoric/vow").Vow<import("@agoric/ertp/src/types.js").NatAmount | import("@agoric/vow").Vow<import("@agoric/ertp/src/types.js").NatAmount>>;
@@ -108,7 +111,7 @@ export function startStakeBld({ consume: { agoricNames: agoricNamesP, board, cha
                             transfer(amount: import("../orchestration-api.js").AmountArg, destination: import("../orchestration-api.js").ChainAddress, opts?: import("../cosmos-api.js").IBCMsgTransferOptions | undefined): import("@agoric/vow").Vow<void>;
                             transferSteps(amount: import("../orchestration-api.js").AmountArg, msg: import("../orchestration-api.js").TransferMsg): import("@agoric/vow").Vow<void>;
                         }>;
-                    }, undefined>>;
+                    }>, undefined>>;
                 }>;
             }>>;
         };

package/src/proposals/start-stakeBld.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"start-stakeBld.d.ts","sourceRoot":"","sources":["start-stakeBld.js"],"names":[],"mappings":"AAkBO,6TAVI,eAAe,GAAG;IAC5B,YAAgB,EAAE;QAClB,OAAa,EAAE;YACf,QAAgB,EAAE,YAAY,CAC9B;;;;;;+BAiCqB,kBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAjC2B,CACxD,CAAC;SACH,CAAC;KACH,CAAC;CACH,iBAwDH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BN;sBApGqB,gCAAgC"}
+{"version":3,"file":"start-stakeBld.d.ts","sourceRoot":"","sources":["start-stakeBld.js"],"names":[],"mappings":"AAkBO,6TAVI,eAAe,GAAG;IAC5B,YAAgB,EAAE;QAClB,OAAa,EAAE;YACf,QAAgB,EAAE,YAAY,CAC9B;;;;;;+BAiCqB,kBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAjC2B,CACxD,CAAC;SACH,CAAC;KACH,CAAC;CACH,iBAwDH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BN;sBApGqB,gCAAgC"}

package/src/proposals/start-stakeOsmo.d.ts

@@ -9,12 +9,12 @@ export function startStakeOsmo({ consume: { agoricNames, board, chainStorage, ch
             }, baggage: import("@agoric/vat-data").Baggage) => Promise<{
                 publicFacet: import("@endo/exo").Guarded<{
                     makeAccount(): Promise<import("@endo/exo").Guarded<{
-                        asContinuingOffer(): {
+                        asContinuingOffer(): import("@agoric/vow").Vow<{
                             publicSubscribers: {
                                 account: {
                                     description: string;
                                     subscriber: globalThis.Subscriber<import("../exos/cosmos-orchestration-account.js").ComosOrchestrationAccountNotification>;
-                                    storagePath: Promise<string>;
+                                    storagePath: string;
                                 };
                             };
                             invitationMakers: import("@endo/exo").Guarded<{
@@ -26,14 +26,14 @@ export function startStakeOsmo({ consume: { agoricNames, board, chainStorage, ch
                                 TransferAccount(): never;
                             }>;
                             holder: import("@endo/exo").Guarded<any>;
-                        };
-                        getPublicTopics(): {
+                        }>;
+                        getPublicTopics(): import("@agoric/vow").Vow<{
                             account: {
                                 description: string;
                                 subscriber: globalThis.Subscriber<import("../exos/cosmos-orchestration-account.js").ComosOrchestrationAccountNotification>;
-                                storagePath: Promise<string>;
+                                storagePath: string;
                             };
-                        };
+                        }>;
                         getAddress(): import("../orchestration-api.js").ChainAddress;
                         delegate(validator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): import("@agoric/vow").Vow<undefined>;
                         getBalances(): import("@agoric/vow").Vow<never>;
@@ -46,12 +46,12 @@ export function startStakeOsmo({ consume: { agoricNames, board, chainStorage, ch
                         withdrawRewards(): import("@agoric/vow").Vow<never>;
                         undelegate(delegations: Omit<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").Delegation, "delegatorAddress">[]): import("@agoric/vow").Vow<undefined>;
                     }>>;
-                    makeAccountInvitationMaker(): Promise<Invitation<{
+                    makeAccountInvitationMaker(): Promise<Invitation<import("@agoric/vow").Vow<{
                         publicSubscribers: {
                             account: {
                                 description: string;
                                 subscriber: globalThis.Subscriber<import("../exos/cosmos-orchestration-account.js").ComosOrchestrationAccountNotification>;
-                                storagePath: Promise<string>;
+                                storagePath: string;
                             };
                         };
                         invitationMakers: import("@endo/exo").Guarded<{
@@ -63,7 +63,7 @@ export function startStakeOsmo({ consume: { agoricNames, board, chainStorage, ch
                             TransferAccount(): never;
                         }>;
                         holder: import("@endo/exo").Guarded<any>;
-                    }, undefined>>;
+                    }>, undefined>>;
                 }>;
             }>>;
         };

package/src/utils/orchestrationAccount.d.ts

@@ -5,5 +5,7 @@ export namespace orchestrationAccountMethods {
     let send: import("@endo/patterns").MethodGuard;
     let transfer: import("@endo/patterns").MethodGuard;
     let transferSteps: import("@endo/patterns").MethodGuard;
+    let asContinuingOffer: import("@endo/patterns").MethodGuard;
+    let getPublicTopics: import("@endo/patterns").MethodGuard;
 }
 //# sourceMappingURL=orchestrationAccount.d.ts.map

package/src/utils/orchestrationAccount.js

@@ -1,6 +1,7 @@
 import { M } from '@endo/patterns';
 import { Shape as NetworkShape } from '@agoric/network';
 import { VowShape } from '@agoric/vow';
+import { TopicsRecordShape } from '@agoric/zoe/src/contractSupport/topics.js';
 import { AmountArgShape, ChainAddressShape, CoinShape } from '../typeGuards.js';
 
 /** @import {OrchestrationAccountI} from '../orchestration-api.js'; */
@@ -17,4 +18,12 @@ export const orchestrationAccountMethods = {
     .optional(M.record())
     .returns(VowShape),
   transferSteps: M.call(AmountArgShape, M.any()).returns(VowShape),
+  asContinuingOffer: M.call().returns(
+    Vow$({
+      publicSubscribers: TopicsRecordShape,
+      invitationMakers: M.any(),
+      holder: M.remotable(),
+    }),
+  ),
+  getPublicTopics: M.call().returns(Vow$(TopicsRecordShape)),
 };

package/src/utils/start-helper.d.ts

@@ -17,15 +17,61 @@ export function provideOrchestration(zcf: ZCF, baggage: Baggage, remotePowers: O
         allVows: (maybeVows: import("@agoric/vow").EVow<unknown>[]) => import("@agoric/vow").Vow<any[]>;
         asVow: <T extends unknown>(fn: (...args: any[]) => import("@agoric/vow").Vow<Awaited<T>> | Awaited<T> | import("@agoric/vow").PromiseVow<T>) => import("@agoric/vow").Vow<Awaited<T>>;
         asPromise: import("@agoric/vow").AsPromiseFunction;
-        retriable: <T>(fnZone: Zone, name: string, fn: (...args: unknown[]) => import("@agoric/vow").ERef<T>) => (...args: unknown[]) => import("@agoric/vow").Vow<T>;
+        retriable: <F extends (...args: any[]) => any>(fnZone: Zone, name: string, fn: F) => PromiseToVow<F>;
+    };
+    zoeTools: {
+        localTransfer: (srcSeat: ZCFSeat, localAccount: import("@endo/exo").Guarded<{
+            asContinuingOffer(): import("@agoric/vow").Vow<{
+                publicSubscribers: {
+                    account: {
+                        description: string;
+                        subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
+                        storagePath: string;
+                    };
+                };
+                invitationMakers: import("@endo/exo").Guarded<{
+                    Delegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<import("@agoric/vow").Vow<Record<unknown, unknown>>, undefined>>;
+                    Undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<import("@agoric/vow").Vow<import("@agoric/time").TimestampRecord>, undefined>>;
+                    CloseAccount(): never;
+                }>;
+                holder: import("@endo/exo").Guarded<any>;
+            }>;
+            getBalance(denom: import("../orchestration-api.js").DenomArg): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount>;
+            getBalances(): import("@agoric/vow").Vow<never>;
+            getPublicTopics(): import("@agoric/vow").Vow<{
+                account: {
+                    description: string;
+                    subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
+                    storagePath: string;
+                };
+            }>;
+            delegate(validatorAddress: string, ertpAmount: Amount<"nat">): import("@agoric/vow").Vow<Record<unknown, unknown>>;
+            undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): import("@agoric/vow").Vow<void | import("@agoric/time").TimestampRecord>;
+            deposit(payment: globalThis.Payment<"nat">, optAmountShape?: globalThis.Pattern): import("@agoric/vow").Vow<import("@agoric/ertp/src/types.js").NatAmount | import("@agoric/vow").Vow<import("@agoric/ertp/src/types.js").NatAmount>>;
+            withdraw(amount: import("@agoric/ertp/src/types.js").NatAmount): import("@agoric/vow").Vow<globalThis.Payment<"nat"> | import("@agoric/vow").Vow<globalThis.Payment<"nat">>>;
+            executeTx(messages: {
+                '@type': string;
+            }[]): import("@agoric/vow").Vow<import("@agoric/cosmic-proto").JsonSafe<{
+                '@type': string;
+            }>[]>;
+            getAddress(): import("../orchestration-api.js").ChainAddress;
+            send(toAccount: any, amount: any): import("@agoric/vow").Vow<never>;
+            transfer(amount: import("../orchestration-api.js").AmountArg, destination: import("../orchestration-api.js").ChainAddress, opts?: import("../cosmos-api.js").IBCMsgTransferOptions | undefined): import("@agoric/vow").Vow<void>;
+            transferSteps(amount: import("../orchestration-api.js").AmountArg, msg: import("../orchestration-api.js").TransferMsg): import("@agoric/vow").Vow<void>;
+        }>, give: AmountKeywordRecord) => import("@agoric/vow").Vow<void>;
     };
     zone: Zone;
-    orchestrate<GuestReturn, HostReturn, GuestContext, HostContext, GuestArgs extends any[], HostArgs extends any[]>(durableName: string, hostCtx: HostContext, guestFn: (guestOrc: import("../orchestration-api.js").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;
     }>;
+    orchestrate: <GuestReturn, HostReturn, GuestContext, HostContext, GuestArgs extends any[], HostArgs extends any[]>(durableName: string, hostCtx: HostContext, guestFn: (guestOrc: import("../orchestration-api.js").Orchestrator, guestCtx: GuestContext, ...args: GuestArgs) => Promise<GuestReturn>) => (...args: HostArgs) => Promise<HostReturn>;
+    orchestrateAll: (guestFns: {
+        [durableName: string]: (...args: any[]) => any;
+    }, hostCtx: any) => {
+        [k: string]: (...args: any[]) => Promise<any>;
+    };
 };
 export function withOrchestration<CT extends Record<string, unknown>, PA extends OrchestrationPowers & {
     marshaller: Marshaller;

package/src/utils/start-helper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"start-helper.d.ts","sourceRoot":"","sources":["start-helper.js"],"names":[],"mappings":"AAyCO,0CALI,GAAG,WACH,OAAO,gBACP,mBAAmB,cACnB,UAAU;;;;;;;;;;;;;;;;;wCAwC0B,GAAG;;wDA9Cd,GAAG,uDAC9B,GAAG;;;4PAsEK,GAAa,4CAK1B,GAAG;;;;;;EAaN;AAuBM,kCAdgC,EAAE,SAA3B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAE,EAGhC,EAAE,SAFM,mBAAmB,GAAG;IACnC,UAAc,EAAE,UAAU,CAAC;CACvB,EACQ,CAAC,cACH,CACV,GAAO,EAAE,GAAG,CAAC,EAAE,CAAC,EAChB,WAAe,EAAE,EAAE,EACnB,IAAQ,EAAE,IAAI,EACd,KAAS,EAAE,kBAAkB,KACtB,OAAO,CAAC,CAAC,CAAC,GACL,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,CAYzE;kCAnIU;IACZ,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,oBAAwB,EAAE,OAAO,uBAAuB,CAAC,CAAC;IAC1D,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;CAC9B;iCAgGU,IAAI,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,EAAE,MAAM,CAAC;6BA9GzC,kBAAkB;0BAGrB,cAAc;gCALR,gCAAgC;4BAIpC,aAAa;6CAEI,sCAAsC;kCALrC,cAAc;6BAE/B,cAAc"}
+{"version":3,"file":"start-helper.d.ts","sourceRoot":"","sources":["start-helper.js"],"names":[],"mappings":"AA8CO,0CALI,GAAG,WACH,OAAO,gBACP,mBAAmB,cACnB,UAAU;;;;;;;;;;;;;;;;;wCA+B+B,GAAG;;+BA/BtD,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8PAeA,GAAO,8CAEe,GAAG;;gCAgCzB,GAAE;;;;EAuDL;AAuBM,kCAdgC,EAAE,SAA3B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAE,EAGhC,EAAE,SAFM,mBAAmB,GAAG;IACnC,UAAc,EAAE,UAAU,CAAC;CACvB,EACQ,CAAC,cACH,CACV,GAAO,EAAE,GAAG,CAAC,EAAE,CAAC,EAChB,WAAe,EAAE,EAAE,EACnB,IAAQ,EAAE,IAAI,EACd,KAAS,EAAE,kBAAkB,KACtB,OAAO,CAAC,CAAC,CAAC,GACL,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,CAYzE;kCA1JU;IACZ,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,oBAAwB,EAAE,OAAO,uBAAuB,CAAC,CAAC;IAC1D,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;CAC9B;iCAuHU,IAAI,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,EAAE,MAAM,CAAC;6BArIzC,kBAAkB;0BAGrB,cAAc;gCALR,gCAAgC;4BAIpC,aAAa;6CAEI,sCAAsC;kCALrC,cAAc;6BAE/B,cAAc"}

package/src/utils/start-helper.js

@@ -1,13 +1,16 @@
 import { prepareAsyncFlowTools } from '@agoric/async-flow';
+import { pickFacet } from '@agoric/vat-data';
 import { prepareVowTools } from '@agoric/vow';
 import { prepareRecorderKitMakers } from '@agoric/zoe/src/contractSupport/recorder.js';
 import { makeDurableZone } from '@agoric/zone/durable.js';
-import { prepareLocalOrchestrationAccountKit } from '../exos/local-orchestration-account.js';
-import { makeOrchestrationFacade } from '../facade.js';
 import { makeChainHub } from '../exos/chain-hub.js';
-import { prepareRemoteChainFacade } from '../exos/remote-chain-facade.js';
 import { prepareCosmosOrchestrationAccount } from '../exos/cosmos-orchestration-account.js';
 import { prepareLocalChainFacade } from '../exos/local-chain-facade.js';
+import { prepareLocalOrchestrationAccountKit } from '../exos/local-orchestration-account.js';
+import { prepareOrchestratorKit } from '../exos/orchestrator.js';
+import { prepareRemoteChainFacade } from '../exos/remote-chain-facade.js';
+import { makeOrchestrationFacade } from '../facade.js';
+import { makeZoeTools } from './zoe-tools.js';
 
 /**
  * @import {PromiseKit} from '@endo/promise-kit'
@@ -34,6 +37,8 @@ import { prepareLocalChainFacade } from '../exos/local-chain-facade.js';
  * Helper that a contract start function can use to set up the objects needed
  * for orchestration.
  *
+ * TODO strip problematic operations from ZCF (e.g., getPayouts)
+ *
  * @param {ZCF} zcf
  * @param {Baggage} baggage
  * @param {OrchestrationPowers} remotePowers
@@ -58,6 +63,7 @@ export const provideOrchestration = (
       contract: zone.subZone('contract'),
       orchestration: zone.subZone('orchestration'),
       vows: zone.subZone('vows'),
+      zoe: zone.subZone('zoe'),
     };
   })();
 
@@ -67,6 +73,8 @@ export const provideOrchestration = (
 
   const chainHub = makeChainHub(agoricNames, vowTools);
 
+  const zoeTools = makeZoeTools(zones.zoe, { zcf, vowTools });
+
   const { makeRecorderKit } = prepareRecorderKitMakers(baggage, marshaller);
   const makeLocalOrchestrationAccountKit = prepareLocalOrchestrationAccountKit(
     zones.orchestration,
@@ -106,20 +114,38 @@ export const provideOrchestration = (
     vowTools,
   });
 
-  const facade = makeOrchestrationFacade({
-    zcf,
-    zone: zones.orchestration,
+  const makeOrchestratorKit = prepareOrchestratorKit(zones.orchestration, {
+    asyncFlowTools,
     chainHub,
-    makeLocalOrchestrationAccountKit,
+    localchain: remotePowers.localchain,
     makeRecorderKit,
-    makeCosmosOrchestrationAccount,
     makeLocalChainFacade,
     makeRemoteChainFacade,
+    storageNode: remotePowers.storageNode,
+    orchestrationService: remotePowers.orchestrationService,
+    timerService,
+    vowTools,
+    zcf,
+  });
+
+  const makeOrchestrator = pickFacet(makeOrchestratorKit, 'orchestrator');
+
+  const facade = makeOrchestrationFacade({
+    zcf,
+    zone: zones.orchestration,
+    makeRecorderKit,
+    makeOrchestrator,
     asyncFlowTools,
     vowTools,
     ...remotePowers,
   });
-  return { ...facade, chainHub, vowTools, zone: zones.contract };
+  return {
+    ...facade,
+    chainHub,
+    vowTools,
+    zoeTools,
+    zone: zones.contract,
+  };
 };
 harden(provideOrchestration);
 

package/src/utils/zoe-tools.d.ts

@@ -0,0 +1,48 @@
+export function makeZoeTools(zone: Zone, { zcf, vowTools }: {
+    zcf: ZCF;
+    vowTools: VowTools;
+}): {
+    localTransfer: (srcSeat: ZCFSeat, localAccount: import("@endo/exo").Guarded<{
+        asContinuingOffer(): Vow<{
+            publicSubscribers: {
+                account: {
+                    description: string;
+                    subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
+                    storagePath: string;
+                };
+            };
+            invitationMakers: import("@endo/exo").Guarded<{
+                Delegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<Vow<Record<unknown, unknown>>, undefined>>;
+                Undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<Vow<import("@agoric/time").TimestampRecord>, undefined>>;
+                CloseAccount(): never;
+            }>;
+            holder: import("@endo/exo").Guarded<any>;
+        }>;
+        getBalance(denom: import("../orchestration-api.js").DenomArg): Vow<import("../orchestration-api.js").DenomAmount>;
+        getBalances(): Vow<never>;
+        getPublicTopics(): Vow<{
+            account: {
+                description: string;
+                subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
+                storagePath: string;
+            };
+        }>;
+        delegate(validatorAddress: string, ertpAmount: Amount<"nat">): Vow<Record<unknown, unknown>>;
+        undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Vow<void | import("@agoric/time").TimestampRecord>;
+        deposit(payment: globalThis.Payment<"nat">, optAmountShape?: globalThis.Pattern): Vow<import("@agoric/ertp/src/types.js").NatAmount | Vow<import("@agoric/ertp/src/types.js").NatAmount>>;
+        withdraw(amount: import("@agoric/ertp/src/types.js").NatAmount): Vow<globalThis.Payment<"nat"> | Vow<globalThis.Payment<"nat">>>;
+        executeTx(messages: {
+            '@type': string;
+        }[]): Vow<import("@agoric/cosmic-proto").JsonSafe<{
+            '@type': string;
+        }>[]>;
+        getAddress(): import("../orchestration-api.js").ChainAddress;
+        send(toAccount: any, amount: any): Vow<never>;
+        transfer(amount: import("../orchestration-api.js").AmountArg, destination: import("../orchestration-api.js").ChainAddress, opts?: import("../cosmos-api.js").IBCMsgTransferOptions | undefined): Vow<void>;
+        transferSteps(amount: import("../orchestration-api.js").AmountArg, msg: import("../orchestration-api.js").TransferMsg): Vow<void>;
+    }>, give: AmountKeywordRecord) => Vow<void>;
+};
+import type { Zone } from '@agoric/zone';
+import type { VowTools } from '@agoric/vow';
+import type { Vow } from '@agoric/vow';
+//# sourceMappingURL=zoe-tools.d.ts.map

package/src/utils/zoe-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zoe-tools.d.ts","sourceRoot":"","sources":["zoe-tools.js"],"names":[],"mappings":"AAcO,mCAHI,IAAI,qBACJ;IAAE,GAAG,EAAE,GAAG,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmD1C;0BAzDsB,cAAc;8BADL,aAAa;yBAAb,aAAa"}

package/src/utils/zoe-tools.js

@@ -0,0 +1,64 @@
+import { Fail } from '@endo/errors';
+import { atomicTransfer } from '@agoric/zoe/src/contractSupport/index.js';
+
+/**
+ * @import {LocalOrchestrationAccountKit} from '../exos/local-orchestration-account.js';
+ * @import {Vow, VowTools} from '@agoric/vow';
+ * @import {Zone} from '@agoric/zone';
+ * @import {OrchestrationAccount} from '../orchestration-api.js'
+ */
+
+/**
+ * @param {Zone} zone
+ * @param {{ zcf: ZCF; vowTools: VowTools }} io
+ */
+export const makeZoeTools = (zone, { zcf, vowTools }) => {
+  /**
+   * Transfer the `give` a seat to a local account.
+   */
+  const localTransfer = vowTools.retriable(
+    zone,
+    'localTransfer',
+    /**
+     * @type {(
+     *   srcSeat: ZCFSeat,
+     *   localAccount: LocalOrchestrationAccountKit['holder'],
+     *   give: AmountKeywordRecord,
+     * ) => Promise<void>}
+     */
+    async (srcSeat, localAccount, give) => {
+      !srcSeat.hasExited() || Fail`The seat cannot have exited.`;
+      const { zcfSeat: tempSeat, userSeat: userSeatP } = zcf.makeEmptySeatKit();
+      const userSeat = await userSeatP;
+      atomicTransfer(zcf, srcSeat, tempSeat, give);
+      tempSeat.exit();
+      // TODO get the userSeat into baggage so it's at least recoverable
+      // const userSeat = await subzone.makeOnce(
+      //   'localTransferHelper',
+      //   async () => {
+      //     const { zcfSeat: tempSeat, userSeat: userSeatP } =
+      //       zcf.makeEmptySeatKit();
+      //     const uSeat = await userSeatP;
+      //     // TODO how do I store in the place for this retriable?
+      //     atomicTransfer(zcf, srcSeat, tempSeat, give);
+      //     tempSeat.exit();
+      //     return uSeat;
+      //   },
+      // );
+
+      // Now all the `give` are accessible, so we can move them to the localAccount`
+
+      const promises = Object.entries(give).map(async ([kw, _amount]) => {
+        const pmt = await userSeat.getPayout(kw);
+        // TODO arrange recovery on upgrade of pmt?
+        return localAccount.deposit(pmt);
+      });
+      await Promise.all(promises);
+      // TODO remove userSeat from baggage
+    },
+  );
+
+  return harden({
+    localTransfer,
+  });
+};