@agoric/orchestration 0.1.1-dev-bc48a8b.0 → 0.1.1-dev-0b6d5f3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/orchestration",
-  "version": "0.1.1-dev-bc48a8b.0+bc48a8b",
+  "version": "0.1.1-dev-0b6d5f3.0+0b6d5f3",
   "description": "Chain abstraction for Agoric's orchestration clients",
   "type": "module",
   "main": "index.js",
@@ -33,19 +33,19 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/async-flow": "0.1.1-dev-bc48a8b.0+bc48a8b",
-    "@agoric/cosmic-proto": "0.4.1-dev-bc48a8b.0+bc48a8b",
-    "@agoric/ertp": "0.16.3-dev-bc48a8b.0+bc48a8b",
-    "@agoric/internal": "0.3.3-dev-bc48a8b.0+bc48a8b",
-    "@agoric/network": "0.1.1-dev-bc48a8b.0+bc48a8b",
-    "@agoric/notifier": "0.6.3-dev-bc48a8b.0+bc48a8b",
-    "@agoric/store": "0.9.3-dev-bc48a8b.0+bc48a8b",
-    "@agoric/time": "0.3.3-dev-bc48a8b.0+bc48a8b",
-    "@agoric/vat-data": "0.5.3-dev-bc48a8b.0+bc48a8b",
-    "@agoric/vats": "0.15.2-dev-bc48a8b.0+bc48a8b",
-    "@agoric/vow": "0.1.1-dev-bc48a8b.0+bc48a8b",
-    "@agoric/zoe": "0.26.3-dev-bc48a8b.0+bc48a8b",
-    "@agoric/zone": "0.2.3-dev-bc48a8b.0+bc48a8b",
+    "@agoric/async-flow": "0.1.1-dev-0b6d5f3.0+0b6d5f3",
+    "@agoric/cosmic-proto": "0.4.1-dev-0b6d5f3.0+0b6d5f3",
+    "@agoric/ertp": "0.16.3-dev-0b6d5f3.0+0b6d5f3",
+    "@agoric/internal": "0.3.3-dev-0b6d5f3.0+0b6d5f3",
+    "@agoric/network": "0.1.1-dev-0b6d5f3.0+0b6d5f3",
+    "@agoric/notifier": "0.6.3-dev-0b6d5f3.0+0b6d5f3",
+    "@agoric/store": "0.9.3-dev-0b6d5f3.0+0b6d5f3",
+    "@agoric/time": "0.3.3-dev-0b6d5f3.0+0b6d5f3",
+    "@agoric/vat-data": "0.5.3-dev-0b6d5f3.0+0b6d5f3",
+    "@agoric/vats": "0.15.2-dev-0b6d5f3.0+0b6d5f3",
+    "@agoric/vow": "0.1.1-dev-0b6d5f3.0+0b6d5f3",
+    "@agoric/zoe": "0.26.3-dev-0b6d5f3.0+0b6d5f3",
+    "@agoric/zone": "0.2.3-dev-0b6d5f3.0+0b6d5f3",
     "@endo/base64": "^1.0.5",
     "@endo/errors": "^1.2.2",
     "@endo/far": "^1.1.2",
@@ -53,7 +53,7 @@
     "@endo/patterns": "^1.4.0"
   },
   "devDependencies": {
-    "@agoric/swingset-liveslots": "0.10.3-dev-bc48a8b.0+bc48a8b",
+    "@agoric/swingset-liveslots": "0.10.3-dev-0b6d5f3.0+0b6d5f3",
     "@chain-registry/client": "^1.47.4",
     "@cosmjs/amino": "^0.32.3",
     "@cosmjs/proto-signing": "^0.32.3",
@@ -91,5 +91,5 @@
   "typeCoverage": {
     "atLeast": 97.1
   },
-  "gitHead": "bc48a8b2d76799c9c07a0888c496039c29049194"
+  "gitHead": "0b6d5f36027dce27b81f9dab3a37d4fb3f23d81e"
 }

package/src/examples/sendAnywhere.contract.d.ts

@@ -1,9 +1,28 @@
+/**
+ * @import {TimerService} from '@agoric/time';
+ * @import {LocalChain} from '@agoric/vats/src/localchain.js';
+ * @import {NameHub} from '@agoric/vats';
+ * @import {Remote} from '@agoric/vow';
+ * @import {Zone} from '@agoric/zone';
+ * @import {CosmosChainInfo, IBCConnectionInfo} from '../cosmos-api';
+ * @import {CosmosInterchainService} from '../exos/cosmos-interchain-service.js';
+ * @import {OrchestrationTools} from '../utils/start-helper.js';
+ */
+/**
+ * @typedef {{
+ *   localchain: Remote<LocalChain>;
+ *   orchestrationService: Remote<CosmosInterchainService>;
+ *   storageNode: Remote<StorageNode>;
+ *   timerService: Remote<TimerService>;
+ *   agoricNames: Remote<NameHub>;
+ * }} OrchestrationPowers
+ */
 export const SingleAmountRecord: import("@endo/patterns").Matcher;
 export const start: (zcf: ZCF<Record<string, unknown>>, privateArgs: OrchestrationPowers & {
     marshaller: Marshaller;
 }, baggage: import("@agoric/vat-data").Baggage) => Promise<{
     publicFacet: import("@endo/exo").Guarded<{
-        makeSendInvitation(): Promise<Invitation<unknown, never>>;
+        makeSendInvitation(): Promise<Invitation<any, any>>;
     }>;
     creatorFacet: import("@endo/exo").Guarded<{
         /**

package/src/examples/sendAnywhere.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sendAnywhere.contract.d.ts","sourceRoot":"","sources":["sendAnywhere.contract.js"],"names":[],"mappings":"AAoFA,kEAKE;AAwFF;gBAjFiB,UAAU;;;;;;QAwDrB;;;WAGG;;;;;;;;4BADQ,iBAAiB;;GAuBe;kCAtJpC;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;uCAdiD,eAAe;gCAJvC,gCAAgC;4BAEpC,aAAa;6CAGI,sCAAsC;kCANjD,cAAc;6BAEnB,cAAc"}
+{"version":3,"file":"sendAnywhere.contract.d.ts","sourceRoot":"","sources":["sendAnywhere.contract.js"],"names":[],"mappings":"AAWA;;;;;;;;;GASG;AAEH;;;;;;;;GAQG;AAEH,kEAKE;AAkGF;gBA3FiB,UAAU;;;;;;QAkErB;;;WAGG;;;;;;;;4BADQ,iBAAiB;;GAuBe;kCAhHpC;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;uCAZiD,eAAe;gCAJvC,gCAAgC;4BAEpC,aAAa;6CAGI,sCAAsC;kCANjD,cAAc;6BAEnB,cAAc"}

package/src/examples/sendAnywhere.contract.js

@@ -1,15 +1,13 @@
 import { makeStateRecord } from '@agoric/async-flow';
 import { AmountShape } from '@agoric/ertp';
 import { heapVowE } from '@agoric/vow/vat.js';
-import { withdrawFromSeat } from '@agoric/zoe/src/contractSupport/zoeHelpers.js';
 import { InvitationShape } from '@agoric/zoe/src/typeGuards.js';
+import { Fail } from '@endo/errors';
 import { E } from '@endo/far';
-import { M, mustMatch } from '@endo/patterns';
-import { makeResumableAgoricNamesHack } from '../exos/agoric-names-tools.js';
+import { M } from '@endo/patterns';
 import { CosmosChainInfoShape } from '../typeGuards.js';
 import { withOrchestration } from '../utils/start-helper.js';
-
-const { entries } = Object;
+import { orchestrationFns } from './sendAnywhereFlows.js';
 
 /**
  * @import {TimerService} from '@agoric/time';
@@ -19,9 +17,7 @@ const { entries } = Object;
  * @import {Zone} from '@agoric/zone';
  * @import {CosmosChainInfo, IBCConnectionInfo} from '../cosmos-api';
  * @import {CosmosInterchainService} from '../exos/cosmos-interchain-service.js';
- * @import {Orchestrator} from '../types.js'
  * @import {OrchestrationTools} from '../utils/start-helper.js';
- * @import {OrchestrationAccount} from '../orchestration-api.js'
  */
 
 /**
@@ -34,54 +30,6 @@ const { entries } = Object;
  * }} OrchestrationPowers
  */
 
-/**
- * @param {Orchestrator} orch
- * @param {object} ctx
- * @param {ZCF} ctx.zcf
- * @param {any} ctx.agoricNamesTools TODO Give this a better type
- * @param {{ account: OrchestrationAccount<any> | undefined }} ctx.contractState
- * @param {ZCFSeat} seat
- * @param {object} offerArgs
- * @param {string} offerArgs.chainName
- * @param {string} offerArgs.destAddr
- */
-const sendItFn = async (
-  orch,
-  { zcf, agoricNamesTools, contractState },
-  seat,
-  offerArgs,
-) => {
-  mustMatch(offerArgs, harden({ chainName: M.scalar(), destAddr: M.string() }));
-  const { chainName, destAddr } = offerArgs;
-  const { give } = seat.getProposal();
-  const [[kw, amt]] = entries(give);
-  const { denom } = await agoricNamesTools.findBrandInVBank(amt.brand);
-  const chain = await orch.getChain(chainName);
-
-  if (!contractState.account) {
-    const agoricChain = await orch.getChain('agoric');
-    contractState.account = await agoricChain.makeAccount();
-    console.log('contractState.account', contractState.account);
-  }
-
-  const info = await chain.getChainInfo();
-  console.log('info', info);
-  const { chainId } = info;
-  assert(typeof chainId === 'string', 'bad chainId');
-  const { [kw]: pmtP } = await withdrawFromSeat(zcf, seat, give);
-  // #9212 types for chain account helpers
-  // @ts-expect-error LCA should have .deposit() method
-  await E.when(pmtP, pmt => contractState.account?.deposit(pmt));
-  await contractState.account?.transfer(
-    { denom, value: amt.value },
-    {
-      value: destAddr,
-      encoding: 'bech32',
-      chainId,
-    },
-  );
-};
-
 export const SingleAmountRecord = M.and(
   M.recordOf(M.string(), AmountShape, {
     numPropertiesLimit: 1,
@@ -103,26 +51,36 @@ const contract = async (
   zcf,
   privateArgs,
   zone,
-  { chainHub, orchestrate, vowTools },
+  { chainHub, orchestrateAll, vowTools, zoeTools },
 ) => {
-  const agoricNamesTools = makeResumableAgoricNamesHack(zone, {
-    agoricNames: privateArgs.agoricNames,
-    vowTools,
-  });
-
   const contractState = makeStateRecord(
     /** @type {{ account: OrchestrationAccount<any> | undefined }} */ {
       account: undefined,
     },
   );
 
-  /** @type {OfferHandler} */
-  const sendIt = orchestrate(
-    'sendIt',
-    { zcf, agoricNamesTools, contractState },
-    sendItFn,
+  // TODO should be a provided helper
+  const findBrandInVBank = vowTools.retriable(
+    zone,
+    'findBrandInVBank',
+    /** @param {Brand} brand */
+    async brand => {
+      const { agoricNames } = privateArgs;
+      const assets = await E(E(agoricNames).lookup('vbankAsset')).values();
+      const it = assets.find(a => a.brand === brand);
+      it || Fail`brand ${brand} not in agoricNames.vbankAsset`;
+      return it;
+    },
   );
 
+  // orchestrate uses the names on orchestrationFns to do a "prepare" of the associated behavior
+  const orchFns = orchestrateAll(orchestrationFns, {
+    zcf,
+    contractState,
+    localTransfer: zoeTools.localTransfer,
+    findBrandInVBank,
+  });
+
   const publicFacet = zone.exo(
     'Send PF',
     M.interface('Send PF', {
@@ -131,7 +89,7 @@ const contract = async (
     {
       makeSendInvitation() {
         return zcf.makeInvitation(
-          sendIt,
+          orchFns.sendIt,
           'send',
           undefined,
           M.splitRecord({ give: SingleAmountRecord }),

package/src/examples/sendAnywhereFlows.d.ts

@@ -0,0 +1,24 @@
+export namespace orchestrationFns {
+    /**
+     * @param {Orchestrator} orch
+     * @param {object} ctx
+     * @param {{ account: OrchestrationAccount<any> }} ctx.contractState
+     * @param {any} ctx.localTransfer
+     * @param {any} ctx.findBrandInVBank
+     * @param {ZCFSeat} seat
+     * @param {{ chainName: string; destAddr: string }} offerArgs
+     */
+    function sendIt(orch: Orchestrator, { contractState, localTransfer, findBrandInVBank }: {
+        contractState: {
+            account: OrchestrationAccount<any>;
+        };
+        localTransfer: any;
+        findBrandInVBank: any;
+    }, seat: ZCFSeat, offerArgs: {
+        chainName: string;
+        destAddr: string;
+    }): Promise<void>;
+}
+import type { Orchestrator } from '../types.js';
+import type { OrchestrationAccount } from '../types.js';
+//# sourceMappingURL=sendAnywhereFlows.d.ts.map

package/src/examples/sendAnywhereFlows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sendAnywhereFlows.d.ts","sourceRoot":"","sources":["sendAnywhereFlows.js"],"names":[],"mappings":";IAYE;;;;;;;;OAQG;IACH,sBARW,YAAY,sDAEpB;QAAoD,aAAa,EAAzD;YAAE,OAAO,EAAE,qBAAqB,GAAG,CAAC,CAAA;SAAE;QAC7B,aAAa,EAAtB,GAAG;QACM,gBAAgB,EAAzB,GAAG;KACX,QAAQ,OAAO,aACP;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,iBAsCjD;;kCAtDkD,aAAa;0CAAb,aAAa"}

package/src/examples/sendAnywhereFlows.js

@@ -0,0 +1,59 @@
+import { M, mustMatch } from '@endo/patterns';
+
+/**
+ * @import {Orchestrator, OrchestrationAccount} from '../types.js';
+ */
+
+const { entries } = Object;
+
+// in guest file (the orchestration functions)
+// the second argument is all the endowments provided
+
+export const orchestrationFns = harden({
+  /**
+   * @param {Orchestrator} orch
+   * @param {object} ctx
+   * @param {{ account: OrchestrationAccount<any> }} ctx.contractState
+   * @param {any} ctx.localTransfer
+   * @param {any} ctx.findBrandInVBank
+   * @param {ZCFSeat} seat
+   * @param {{ chainName: string; destAddr: string }} offerArgs
+   */
+  async sendIt(
+    orch,
+    { contractState, localTransfer, findBrandInVBank },
+    seat,
+    offerArgs,
+  ) {
+    mustMatch(
+      offerArgs,
+      harden({ chainName: M.scalar(), destAddr: M.string() }),
+    );
+    const { chainName, destAddr } = offerArgs;
+    // NOTE the proposal shape ensures that the `give` is a single asset
+    const { give } = seat.getProposal();
+    const [[_kw, amt]] = entries(give);
+    const { denom } = await findBrandInVBank(amt.brand);
+    const chain = await orch.getChain(chainName);
+
+    if (!contractState.account) {
+      const agoricChain = await orch.getChain('agoric');
+      contractState.account = await agoricChain.makeAccount();
+    }
+
+    const info = await chain.getChainInfo();
+    const { chainId } = info;
+    assert(typeof chainId === 'string', 'bad chainId');
+
+    await localTransfer(seat, contractState.account, give);
+
+    await contractState.account.transfer(
+      { denom, value: amt.value },
+      {
+        value: destAddr,
+        encoding: 'bech32',
+        chainId,
+      },
+    );
+  },
+});

package/src/examples/swapExample.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swapExample.contract.d.ts","sourceRoot":"","sources":["swapExample.contract.js"],"names":[],"mappings":"AAoEA,yCAAyC;AACzC,mBADW,YAAY,CAAC,OAAO,KAAK,CAAC,CAWnC;AASK,0CAHI,KAAK;;;EAIsC;AA+CtD;iBAxCkB,OAAO,OAAO,CAAC;gBAChB,OAAO,UAAU,CAAC;0BACR,OAAO,uBAAuB,CAAC;iBACxC,OAAO,WAAW,CAAC;kBAClB,OAAO,YAAY,CAAC;gBACtB,UAAU;;;;oBAYV,MAAM,CAAC,KAAK,CAAC;uBAAa,sBAAsB;;;GAuBhB;6BA1HvB,cAAc;4BAFf,kBAAkB;gCADd,gCAAgC;6CAEnB,sCAAsC;kCAHjD,cAAc;4CADsB,aAAa"}
+{"version":3,"file":"swapExample.contract.d.ts","sourceRoot":"","sources":["swapExample.contract.js"],"names":[],"mappings":"AA8DA,yCAAyC;AACzC,mBADW,YAAY,CAAC,OAAO,KAAK,CAAC,CAWnC;AASK,0CAHI,KAAK;;;EAIsC;AAmDtD;iBA5CkB,OAAO,OAAO,CAAC;gBAChB,OAAO,UAAU,CAAC;0BACR,OAAO,uBAAuB,CAAC;iBACxC,OAAO,WAAW,CAAC;kBAClB,OAAO,YAAY,CAAC;gBACtB,UAAU;;;;oBAYV,MAAM,CAAC,KAAK,CAAC;uBAAa,sBAAsB;;;GA2BhB;6BA1HvB,cAAc;4BAFf,kBAAkB;gCADd,gCAAgC;6CAEnB,sCAAsC;kCAHjD,cAAc;4CADU,aAAa"}

package/src/examples/swapExample.contract.js

@@ -1,13 +1,11 @@
 import { StorageNodeShape } from '@agoric/internal';
 import { TimerServiceShape } from '@agoric/time';
-import { withdrawFromSeat } from '@agoric/zoe/src/contractSupport/zoeHelpers.js';
-import { deeplyFulfilled } from '@endo/marshal';
-import { M, objectMap } from '@endo/patterns';
+import { M } from '@endo/patterns';
 import { orcUtils } from '../utils/orc.js';
 import { withOrchestration } from '../utils/start-helper.js';
 
 /**
- * @import {Orchestrator, IcaAccount, CosmosValidatorAddress} from '../types.js'
+ * @import {Orchestrator, CosmosValidatorAddress} from '../types.js'
  * @import {TimerService} from '@agoric/time';
  * @import {LocalChain} from '@agoric/vats/src/localchain.js';
  * @import {Remote} from '@agoric/internal';
@@ -20,13 +18,13 @@ import { withOrchestration } from '../utils/start-helper.js';
 /**
  * @param {Orchestrator} orch
  * @param {object} ctx
- * @param {ZCF} ctx.zcf
+ * @param {OrchestrationTools['zoeTools']['localTransfer']} ctx.localTransfer
  * @param {ZCFSeat} seat
  * @param {object} offerArgs
  * @param {Amount<'nat'>} offerArgs.staked
  * @param {CosmosValidatorAddress} offerArgs.validator
  */
-const stackAndSwapFn = async (orch, { zcf }, seat, offerArgs) => {
+const stackAndSwapFn = async (orch, { localTransfer }, seat, offerArgs) => {
   const { give } = seat.getProposal();
 
   const omni = await orch.getChain('omniflixhub');
@@ -40,13 +38,9 @@ const stackAndSwapFn = async (orch, { zcf }, seat, offerArgs) => {
   const omniAddress = omniAccount.getAddress();
 
   // deposit funds from user seat to LocalChainAccount
-  const payments = await withdrawFromSeat(zcf, seat, give);
-  await deeplyFulfilled(
-    objectMap(payments, payment =>
-      // @ts-expect-error payment is ERef<Payment> which happens to work but isn't officially supported
-      localAccount.deposit(payment),
-    ),
-  );
+  // TODO localTransfer type returns vow but in the guest context it should be a promise
+  // @ts-expect-error XXX localAccount type
+  await localTransfer(seat, localAccount, give);
   seat.exit();
 
   // build swap instructions with orcUtils library
@@ -104,7 +98,7 @@ export const makeNatAmountShape = (brand, min) =>
  * @param {Zone} zone
  * @param {OrchestrationTools} tools
  */
-const contract = async (zcf, privateArgs, zone, { orchestrate }) => {
+const contract = async (zcf, privateArgs, zone, { orchestrate, zoeTools }) => {
   const { brands } = zcf.getTerms();
 
   /** deprecated historical example */
@@ -114,7 +108,11 @@ const contract = async (zcf, privateArgs, zone, { orchestrate }) => {
    *   { staked: Amount<'nat'>; validator: CosmosValidatorAddress }
    * >}
    */
-  const swapAndStakeHandler = orchestrate('LSTTia', { zcf }, stackAndSwapFn);
+  const swapAndStakeHandler = orchestrate(
+    'LSTTia',
+    { zcf, localTransfer: zoeTools.localTransfer },
+    stackAndSwapFn,
+  );
 
   const publicFacet = zone.exo('publicFacet', undefined, {
     makeSwapAndStakeInvitation() {

package/src/exos/orchestrator.d.ts

@@ -71,6 +71,11 @@ export function prepareOrchestratorKit(zone: Zone, { chainHub, localchain, makeL
         asAmount: () => never;
     };
 }>;
+/**
+ * Host side of the Orchestrator interface. (Methods return vows instead of
+ * promises as the interface within the guest function.)
+ */
+export type HostOrchestrator = ReturnType<ReturnType<typeof prepareOrchestratorKit>>["orchestrator"];
 import type { Zone } from '@agoric/base-zone';
 import type { AsyncFlowTools } from '@agoric/async-flow';
 import type { ChainHub } from './chain-hub.js';

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

@@ -1 +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,uBAAuB,CAAC,CAAC;IAC1D,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;6CAHxB,gCAAgC;kCAL3C,cAAc;8BADb,aAAa;+BAU4E,aAAa;uCAAb,aAAa;yBAVtG,aAAa;0CAU4E,aAAa;kCAAb,aAAa;2BAAb,aAAa"}
+{"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,uBAAuB,CAAC,CAAC;IAC1D,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;;;;;+BAMU,UAAU,CACtB,UAAc,CAAC,OAAO,sBAAsB,CAAC,CAC1C,CAAC,cAAc,CAAC;0BApIG,mBAAmB;oCAET,oBAAoB;8BAD1B,gBAAgB;gCAId,gCAAgC;4BAEpC,kBAAkB;qCADI,6CAA6C;0CAKrD,yBAAyB;2CACxB,0BAA0B;6CAHxB,gCAAgC;kCAL3C,cAAc;8BADb,aAAa;+BAU4E,aAAa;uCAAb,aAAa;yBAVtG,aAAa;0CAU4E,aAAa;kCAAb,aAAa;2BAAb,aAAa"}

package/src/exos/orchestrator.js

@@ -139,3 +139,11 @@ export const prepareOrchestratorKit = (
     },
   );
 harden(prepareOrchestratorKit);
+/**
+ * Host side of the Orchestrator interface. (Methods return vows instead of
+ * promises as the interface within the guest function.)
+ *
+ * @typedef {ReturnType<
+ *   ReturnType<typeof prepareOrchestratorKit>
+ * >['orchestrator']} HostOrchestrator
+ */

package/src/facade.d.ts

@@ -1,56 +1,33 @@
-export function makeOrchestrationFacade({ zone, timerService, zcf, storageNode, orchestrationService, localchain, chainHub, makeLocalOrchestrationAccountKit, makeRecorderKit, makeLocalChainFacade, makeRemoteChainFacade, vowTools, asyncFlowTools, }: {
+export function makeOrchestrationFacade({ zone, timerService, zcf, storageNode, orchestrationService, makeRecorderKit, makeOrchestrator, vowTools, asyncFlowTools, }: {
     zone: Zone;
     timerService: Remote<TimerService>;
     zcf: ZCF;
     storageNode: Remote<StorageNode>;
     orchestrationService: Remote<CosmosInterchainService>;
-    localchain: Remote<LocalChain>;
-    chainHub: import("./exos/chain-hub.js").ChainHub;
-    makeLocalOrchestrationAccountKit: MakeLocalOrchestrationAccountKit;
     makeRecorderKit: MakeRecorderKit;
-    makeCosmosOrchestrationAccount: any;
-    makeLocalChainFacade: MakeLocalChainFacade;
-    makeRemoteChainFacade: MakeRemoteChainFacade;
+    makeOrchestrator: () => HostOrchestrator;
     vowTools: VowTools;
     asyncFlowTools: AsyncFlowTools;
 }): {
-    /**
-     * @template GuestReturn
-     * @template HostReturn
-     * @template GuestContext
-     * @template HostContext
-     * @template {any[]} GuestArgs
-     * @template {any[]} HostArgs
-     * @param {string} durableName - the orchestration flow identity in the zone
-     *   (to resume across upgrades)
-     * @param {HostContext} hostCtx - values to pass through the async flow
-     *   membrane
-     * @param {(
-     *   guestOrc: Orchestrator,
-     *   guestCtx: GuestContext,
-     *   ...args: GuestArgs
-     * ) => Promise<GuestReturn>} guestFn
-     * @returns {(...args: HostArgs) => Promise<HostReturn>} TODO returns a
-     *   Promise for now for compat before use of asyncFlow. But really should
-     *   be `Vow<HostReturn>`
-     */
-    orchestrate<GuestReturn, HostReturn, GuestContext, HostContext, GuestArgs extends any[], HostArgs extends any[]>(durableName: string, hostCtx: HostContext, guestFn: (guestOrc: Orchestrator, guestCtx: GuestContext, ...args: GuestArgs) => Promise<GuestReturn>): (...args: HostArgs) => Promise<HostReturn>;
     adminAsyncFlow: import("@endo/exo").Guarded<{
         getFailures(): import("@endo/patterns").CopyMap<any, import("@endo/pass-style").Passable>;
         wakeAll(): void;
         getFlowForOutcomeVow(outcomeVow: any): any;
     }>;
+    orchestrate: <GuestReturn, HostReturn, GuestContext, HostContext, GuestArgs extends any[], HostArgs extends any[]>(durableName: string, hostCtx: HostContext, guestFn: (guestOrc: Orchestrator, guestCtx: GuestContext, ...args: GuestArgs) => Promise<GuestReturn>) => (...args: HostArgs) => Promise<HostReturn>;
+    orchestrateAll: (guestFns: {
+        [durableName: string]: (...args: any[]) => any;
+    }, hostCtx: any) => {
+        [k: string]: (...args: any[]) => Promise<any>;
+    };
 };
 export type OrchestrationFacade = ReturnType<typeof makeOrchestrationFacade>;
 import type { Zone } from '@agoric/zone';
 import type { TimerService } from '@agoric/time';
 import type { Remote } from '@agoric/internal';
 import type { CosmosInterchainService } from './exos/cosmos-interchain-service.js';
-import type { LocalChain } from '@agoric/vats/src/localchain.js';
-import type { MakeLocalOrchestrationAccountKit } from './exos/local-orchestration-account.js';
 import type { MakeRecorderKit } from '@agoric/zoe/src/contractSupport/recorder.js';
-import type { MakeLocalChainFacade } from './exos/local-chain-facade.js';
-import type { MakeRemoteChainFacade } from './exos/remote-chain-facade.js';
+import type { HostOrchestrator } from './exos/orchestrator.js';
 import type { VowTools } from '@agoric/vow';
 import type { AsyncFlowTools } from '@agoric/async-flow';
 import type { Orchestrator } from './types.js';

package/src/facade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"facade.d.ts","sourceRoot":"","sources":["facade.js"],"names":[],"mappings":"AAwCO,yPAjBI;IACV,IAAQ,EAAE,IAAI,CAAC;IACf,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,GAAO,EAAE,GAAG,CAAC;IACb,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,oBAAwB,EAAE,OAAO,uBAAuB,CAAC,CAAC;IAC1D,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,QAAY,EAAE,OAAO,qBAAqB,EAAE,QAAQ,CAAC;IACrD,gCAAoC,EAAE,gCAAgC,CAAC;IACvE,eAAmB,EAAE,eAAe,CAAC;IACrC,8BAAkC,EAAE,GAAG,CAAC;IACxC,oBAAwB,EAAE,oBAAoB,CAAC;IAC/C,qBAAyB,EAAE,qBAAqB,CAAC;IACjD,QAAY,EAAE,QAAQ,CAAC;IACvB,cAAkB,EAAE,cAAc,CAAC;CAChC;IAmDA;;;;;;;;;;;;;;;;;;;OAmBG;gBAlBU,WAAW,EACX,UAAU,EACV,YAAY,EACZ,WAAW,EACH,SAAS,SAAhB,GAAG,EAAG,EACC,QAAQ,SAAf,GAAG,EAAG,eACT,MAAM,WAEN,WAAW,WAEX,CACV,QAAY,EAAE,YAAY,EAC1B,QAAY,EAAE,YAAY,EAC1B,GAAO,IAAI,EAAE,SAAS,KACf,OAAO,CAAC,WAAW,CAAC,GACf,CAAC,GAAG,IAAI,EAAE,QAAQ,KAAK,OAAO,CAAC,UAAU,CAAC;;;;;;EAwB1D;kCAEa,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BA3HjC,cAAc;kCAEN,cAAc;4BAIpB,kBAAkB;6CACD,qCAAqC;gCAHlD,gCAAgC;sDAOV,uCAAuC;qCAN3C,6CAA6C;0CAIrD,8BAA8B;2CAC7B,+BAA+B;8BATvC,aAAa;oCAFZ,oBAAoB;kCASsD,YAAY"}
+{"version":3,"file":"facade.d.ts","sourceRoot":"","sources":["facade.js"],"names":[],"mappings":"AA6BO,sKAZI;IACV,IAAQ,EAAE,IAAI,CAAC;IACf,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,GAAO,EAAE,GAAG,CAAC;IACb,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,oBAAwB,EAAE,OAAO,uBAAuB,CAAC,CAAC;IAC1D,eAAmB,EAAE,eAAe,CAAC;IACrC,gBAAoB,EAAE,MAAM,gBAAgB,CAAC;IAC7C,QAAY,EAAE,QAAQ,CAAC;IACvB,cAAkB,EAAE,cAAc,CAAC;CAChC;;;;;;kBA8BW,WAAW,EACX,UAAU,EACV,YAAY,EACZ,WAAW,EACH,SAAS,SAAhB,GAAG,EAAG,EACC,QAAQ,SAAf,GAAG,EAAG,eACT,MAAM,WAEN,WAAW,WAEX,CACV,QAAY,EAAE,YAAY,EAC1B,QAAY,EAAE,YAAY,EAC1B,GAAO,IAAI,EAAE,SAAS,KACf,OAAO,CAAC,WAAW,CAAC,KACf,CAAC,GAAG,IAAI,EAAE,QAAQ,KAAK,OAAO,CAAC,UAAU,CAAC;+BA4B5C;QAAE,CAAC,WAAW,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAA;KAAE,WAClD,GAAG;yCA7BsB,OAAO,KAAY;;EA4CxD;kCAEa,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BAhHjC,cAAc;kCAEN,cAAc;4BAGpB,kBAAkB;6CACD,qCAAqC;qCAHhC,6CAA6C;sCACzD,wBAAwB;8BAH3B,aAAa;oCAFZ,oBAAoB;kCAQsD,YAAY"}

package/src/facade.js

@@ -1,23 +1,17 @@
-/** @file Orchestration service */
+/** @file Orchestration facade */
 
 import { Fail } from '@endo/errors';
-import { pickFacet } from '@agoric/vat-data';
-import { prepareOrchestratorKit } from './exos/orchestrator.js';
 
 /**
  * @import {AsyncFlowTools} from '@agoric/async-flow';
  * @import {Zone} from '@agoric/zone';
  * @import {Vow, VowTools} from '@agoric/vow';
  * @import {TimerService} from '@agoric/time';
- * @import {IBCConnectionID} from '@agoric/vats';
- * @import {LocalChain} from '@agoric/vats/src/localchain.js';
  * @import {RecorderKit, MakeRecorderKit} from '@agoric/zoe/src/contractSupport/recorder.js'.
+ * @import {HostOrchestrator} from './exos/orchestrator.js';
  * @import {Remote} from '@agoric/internal';
  * @import {CosmosInterchainService} from './exos/cosmos-interchain-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';
  */
 
 /**
@@ -27,13 +21,8 @@ import { prepareOrchestratorKit } from './exos/orchestrator.js';
  *   zcf: ZCF;
  *   storageNode: Remote<StorageNode>;
  *   orchestrationService: Remote<CosmosInterchainService>;
- *   localchain: Remote<LocalChain>;
- *   chainHub: import('./exos/chain-hub.js').ChainHub;
- *   makeLocalOrchestrationAccountKit: MakeLocalOrchestrationAccountKit;
  *   makeRecorderKit: MakeRecorderKit;
- *   makeCosmosOrchestrationAccount: any;
- *   makeLocalChainFacade: MakeLocalChainFacade;
- *   makeRemoteChainFacade: MakeRemoteChainFacade;
+ *   makeOrchestrator: () => HostOrchestrator;
  *   vowTools: VowTools;
  *   asyncFlowTools: AsyncFlowTools;
  * }} powers
@@ -44,12 +33,8 @@ export const makeOrchestrationFacade = ({
   zcf,
   storageNode,
   orchestrationService,
-  localchain,
-  chainHub,
-  makeLocalOrchestrationAccountKit,
   makeRecorderKit,
-  makeLocalChainFacade,
-  makeRemoteChainFacade,
+  makeOrchestrator,
   vowTools,
   asyncFlowTools,
 }) => {
@@ -59,73 +44,75 @@ export const makeOrchestrationFacade = ({
     storageNode &&
     orchestrationService &&
     // @ts-expect-error type says defined but double check
-    makeLocalOrchestrationAccountKit &&
-    // @ts-expect-error type says defined but double check
     makeRecorderKit &&
     // @ts-expect-error type says defined but double check
-    makeRemoteChainFacade &&
+    makeOrchestrator &&
     asyncFlowTools) ||
     Fail`params missing`;
 
-  const makeOrchestratorKit = prepareOrchestratorKit(zone, {
-    asyncFlowTools,
-    chainHub,
-    localchain,
-    makeRecorderKit,
-    makeLocalChainFacade,
-    makeRemoteChainFacade,
-    orchestrationService,
-    storageNode,
-    timerService,
-    vowTools,
-    zcf,
-  });
-  const makeOrchestrator = pickFacet(makeOrchestratorKit, 'orchestrator');
-
   const { prepareEndowment, asyncFlow, adminAsyncFlow } = asyncFlowTools;
 
   const { when } = vowTools;
 
-  return {
-    /**
-     * @template GuestReturn
-     * @template HostReturn
-     * @template GuestContext
-     * @template HostContext
-     * @template {any[]} GuestArgs
-     * @template {any[]} HostArgs
-     * @param {string} durableName - the orchestration flow identity in the zone
-     *   (to resume across upgrades)
-     * @param {HostContext} hostCtx - values to pass through the async flow
-     *   membrane
-     * @param {(
-     *   guestOrc: Orchestrator,
-     *   guestCtx: GuestContext,
-     *   ...args: GuestArgs
-     * ) => Promise<GuestReturn>} guestFn
-     * @returns {(...args: HostArgs) => Promise<HostReturn>} TODO returns a
-     *   Promise for now for compat before use of asyncFlow. But really should
-     *   be `Vow<HostReturn>`
-     */
-    orchestrate(durableName, hostCtx, guestFn) {
-      const subZone = zone.subZone(durableName);
+  /**
+   * @template GuestReturn
+   * @template HostReturn
+   * @template GuestContext
+   * @template HostContext
+   * @template {any[]} GuestArgs
+   * @template {any[]} HostArgs
+   * @param {string} durableName - the orchestration flow identity in the zone
+   *   (to resume across upgrades)
+   * @param {HostContext} hostCtx - values to pass through the async flow
+   *   membrane
+   * @param {(
+   *   guestOrc: Orchestrator,
+   *   guestCtx: GuestContext,
+   *   ...args: GuestArgs
+   * ) => Promise<GuestReturn>} guestFn
+   * @returns {(...args: HostArgs) => Promise<HostReturn>} TODO returns a
+   *   Promise for now for compat before use of asyncFlow. But really should be
+   *   `Vow<HostReturn>`
+   */
+  const orchestrate = (durableName, hostCtx, guestFn) => {
+    const subZone = zone.subZone(durableName);
 
-      const hostOrc = makeOrchestrator();
+    const hostOrc = makeOrchestrator();
 
-      const [wrappedOrc, wrappedCtx] = prepareEndowment(subZone, 'endowments', [
-        hostOrc,
-        hostCtx,
-      ]);
+    const [wrappedOrc, wrappedCtx] = prepareEndowment(subZone, 'endowments', [
+      hostOrc,
+      hostCtx,
+    ]);
 
-      const hostFn = asyncFlow(subZone, 'asyncFlow', guestFn);
+    const hostFn = asyncFlow(subZone, 'asyncFlow', guestFn);
 
-      const orcFn = (...args) =>
-        // TODO remove the `when` after fixing the return type
-        // to `Vow<HostReturn>`
-        when(hostFn(wrappedOrc, wrappedCtx, ...args));
-      return harden(orcFn);
-    },
+    const orcFn = (...args) =>
+      // TODO remove the `when` after fixing the return type
+      // to `Vow<HostReturn>`
+      when(hostFn(wrappedOrc, wrappedCtx, ...args));
+    return harden(orcFn);
+  };
+
+  /**
+   * Orchestrate all the guest functions.
+   *
+   * NOTE multiple calls to this with the same guestFn name will fail
+   *
+   * @param {{ [durableName: string]: (...args: any[]) => any }} guestFns
+   * @param {any} hostCtx
+   */
+  const orchestrateAll = (guestFns, hostCtx) =>
+    Object.fromEntries(
+      Object.entries(guestFns).map(([name, guestFn]) => [
+        name,
+        orchestrate(name, hostCtx, guestFn),
+      ]),
+    );
+
+  return {
     adminAsyncFlow,
+    orchestrate,
+    orchestrateAll,
   };
 };
 harden(makeOrchestrationFacade);

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

@@ -17,15 +17,46 @@ 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<{
+            getBalance(denom: import("../orchestration-api.js").DenomArg): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount>;
+            getBalances(): import("@agoric/vow").Vow<never>;
+            getPublicTopics(): {
+                account: {
+                    description: string;
+                    subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
+                    storagePath: Promise<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,33 @@
+export function makeZoeTools(zone: Zone, { zcf, vowTools }: {
+    zcf: ZCF;
+    vowTools: VowTools;
+}): {
+    localTransfer: (srcSeat: ZCFSeat, localAccount: import("@endo/exo").Guarded<{
+        getBalance(denom: import("../orchestration-api.js").DenomArg): Vow<import("../orchestration-api.js").DenomAmount>;
+        getBalances(): Vow<never>;
+        getPublicTopics(): {
+            account: {
+                description: string;
+                subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
+                storagePath: Promise<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,
+  });
+};