@agoric/orchestration 0.1.1-dev-0ad10c6.0 → 0.1.1-dev-4390d8c.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/orchestration",
-  "version": "0.1.1-dev-0ad10c6.0+0ad10c6",
+  "version": "0.1.1-dev-4390d8c.0+4390d8c",
   "description": "Chain abstraction for Agoric's orchestration clients",
   "type": "module",
   "main": "index.js",
@@ -33,20 +33,20 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-0ad10c6.0+0ad10c6",
-    "@agoric/async-flow": "0.1.1-dev-0ad10c6.0+0ad10c6",
-    "@agoric/cosmic-proto": "0.4.1-dev-0ad10c6.0+0ad10c6",
-    "@agoric/ertp": "0.16.3-dev-0ad10c6.0+0ad10c6",
-    "@agoric/internal": "0.3.3-dev-0ad10c6.0+0ad10c6",
-    "@agoric/network": "0.1.1-dev-0ad10c6.0+0ad10c6",
-    "@agoric/notifier": "0.6.3-dev-0ad10c6.0+0ad10c6",
-    "@agoric/store": "0.9.3-dev-0ad10c6.0+0ad10c6",
-    "@agoric/time": "0.3.3-dev-0ad10c6.0+0ad10c6",
-    "@agoric/vat-data": "0.5.3-dev-0ad10c6.0+0ad10c6",
-    "@agoric/vats": "0.15.2-dev-0ad10c6.0+0ad10c6",
-    "@agoric/vow": "0.1.1-dev-0ad10c6.0+0ad10c6",
-    "@agoric/zoe": "0.26.3-dev-0ad10c6.0+0ad10c6",
-    "@agoric/zone": "0.2.3-dev-0ad10c6.0+0ad10c6",
+    "@agoric/assert": "0.6.1-dev-4390d8c.0+4390d8c",
+    "@agoric/async-flow": "0.1.1-dev-4390d8c.0+4390d8c",
+    "@agoric/cosmic-proto": "0.4.1-dev-4390d8c.0+4390d8c",
+    "@agoric/ertp": "0.16.3-dev-4390d8c.0+4390d8c",
+    "@agoric/internal": "0.3.3-dev-4390d8c.0+4390d8c",
+    "@agoric/network": "0.1.1-dev-4390d8c.0+4390d8c",
+    "@agoric/notifier": "0.6.3-dev-4390d8c.0+4390d8c",
+    "@agoric/store": "0.9.3-dev-4390d8c.0+4390d8c",
+    "@agoric/time": "0.3.3-dev-4390d8c.0+4390d8c",
+    "@agoric/vat-data": "0.5.3-dev-4390d8c.0+4390d8c",
+    "@agoric/vats": "0.15.2-dev-4390d8c.0+4390d8c",
+    "@agoric/vow": "0.1.1-dev-4390d8c.0+4390d8c",
+    "@agoric/zoe": "0.26.3-dev-4390d8c.0+4390d8c",
+    "@agoric/zone": "0.2.3-dev-4390d8c.0+4390d8c",
     "@endo/base64": "^1.0.5",
     "@endo/far": "^1.1.2",
     "@endo/marshal": "^1.5.0",
@@ -90,5 +90,5 @@
   "typeCoverage": {
     "atLeast": 97.1
   },
-  "gitHead": "0ad10c6e7b2871007eb02025c5238ec2a16b7c69"
+  "gitHead": "4390d8c21fd8ac80a9c83f55d38c52e3f98faa1e"
 }

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

@@ -1,22 +1,3 @@
-/**
- * @import {Baggage} from '@agoric/vat-data';
- * @import {CosmosChainInfo, IBCConnectionInfo} from '../cosmos-api';
- * @import {TimerService, TimerBrand} from '@agoric/time';
- * @import {LocalChain} from '@agoric/vats/src/localchain.js';
- * @import {OrchestrationService} from '../service.js';
- * @import {NameHub} from '@agoric/vats';
- * @import {VBankAssetDetail} from '@agoric/vats/tools/board-utils.js';
- * @import {Remote} from '@agoric/vow';
- */
-/**
- * @typedef {{
- *   localchain: Remote<LocalChain>;
- *   orchestrationService: Remote<OrchestrationService>;
- *   storageNode: Remote<StorageNode>;
- *   timerService: Remote<TimerService>;
- *   agoricNames: Remote<NameHub>;
- * }} OrchestrationPowers
- */
 export const SingleAmountRecord: import("@endo/patterns").Matcher;
 export function start(zcf: ZCF, privateArgs: OrchestrationPowers & {
     marshaller: Marshaller;

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

@@ -1 +1 @@
-{"version":3,"file":"sendAnywhere.contract.d.ts","sourceRoot":"","sources":["sendAnywhere.contract.js"],"names":[],"mappings":"AAWA;;;;;;;;;GASG;AAEH;;;;;;;;GAQG;AAEH,kEAKE;AASK,2BANI,GAAG,eACH,mBAAmB,GAAG;IAChC,UAAc,EAAE,UAAU,CAAC;CACxB,WACO,OAAO;;;;;QAgGZ;;;WAGG;4BAFQ,eAAe,kBACf,iBAAiB;;GAmBjC;kCA1IY;IACZ,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;CAC9B;6BAjBsB,kBAAkB;qCACS,eAAe;uCAAf,eAAe;gCAEvC,gCAAgC;4BAIpC,aAAa;0CAHC,eAAe;kCAFX,cAAc;6BAG/B,cAAc"}
+{"version":3,"file":"sendAnywhere.contract.d.ts","sourceRoot":"","sources":["sendAnywhere.contract.js"],"names":[],"mappings":"AAoFA,kEAKE;AASK,2BANI,GAAG,eACH,mBAAmB,GAAG;IAChC,UAAc,EAAE,UAAU,CAAC;CACxB,WACO,OAAO;;;;;QAoDZ;;;WAGG;4BAFQ,eAAe,kBACf,iBAAiB;;GAmBjC;kCAhJY;IACZ,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;CAC9B;6BAlBsB,kBAAkB;qCAKS,eAAe;uCAAf,eAAe;gCAHvC,gCAAgC;4BAEpC,aAAa;0CAEC,eAAe;kCALvB,cAAc;6BAEnB,cAAc"}

package/src/examples/sendAnywhere.contract.js

@@ -2,22 +2,24 @@ import { withdrawFromSeat } from '@agoric/zoe/src/contractSupport/zoeHelpers.js'
 import { InvitationShape } from '@agoric/zoe/src/typeGuards.js';
 import { M, mustMatch } from '@endo/patterns';
 import { heapVowE as E } from '@agoric/vow/vat.js';
+import { makeStateRecord } from '@agoric/async-flow';
 import { AmountShape } from '@agoric/ertp';
 import { CosmosChainInfoShape } from '../typeGuards.js';
 import { provideOrchestration } from '../utils/start-helper.js';
+import { makeResumableAgoricNamesHack } from '../exos/agoric-names-tools.js';
 
 const { entries } = Object;
-const { Fail } = assert;
 
 /**
  * @import {Baggage} from '@agoric/vat-data';
- * @import {CosmosChainInfo, IBCConnectionInfo} from '../cosmos-api';
- * @import {TimerService, TimerBrand} from '@agoric/time';
+ * @import {TimerService} from '@agoric/time';
  * @import {LocalChain} from '@agoric/vats/src/localchain.js';
- * @import {OrchestrationService} from '../service.js';
  * @import {NameHub} from '@agoric/vats';
- * @import {VBankAssetDetail} from '@agoric/vats/tools/board-utils.js';
  * @import {Remote} from '@agoric/vow';
+ * @import {CosmosChainInfo, IBCConnectionInfo} from '../cosmos-api';
+ * @import {OrchestrationService} from '../service.js';
+ * @import {Orchestrator} from '../types.js'
+ * @import {OrchestrationAccount} from '../orchestration-api.js'
  */
 
 /**
@@ -30,6 +32,56 @@ const { Fail } = assert;
  * }} 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> }} 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);
+  // XXX when() until membrane
+  const { denom } = await E.when(agoricNamesTools.findBrandInVBank(amt.brand));
+  const chain = await orch.getChain(chainName);
+
+  // FIXME ok to use a heap var crossing the membrane scope this way?
+  if (!contractState.account) {
+    const agoricChain = await orch.getChain('agoric');
+    // XXX when() until membrane
+    contractState.account = await E.when(agoricChain.makeAccount());
+    console.log('contractState.account', contractState.account);
+  }
+
+  // XXX when() until membrane
+  const info = await E.when(chain.getChainInfo());
+  console.log('info', info);
+  const { chainId } = info;
+  assert(typeof chainId === 'string', 'bad chainId');
+  const { [kw]: pmtP } = await withdrawFromSeat(zcf, seat, give);
+  await E.when(pmtP, pmt => contractState.account.deposit(pmt));
+  await contractState.account.transfer(
+    { denom, value: amt.value },
+    {
+      address: destAddr,
+      addressEncoding: 'bech32',
+      chainId,
+    },
+  );
+};
+
 export const SingleAmountRecord = M.and(
   M.recordOf(M.string(), AmountShape, {
     numPropertiesLimit: 1,
@@ -45,70 +97,26 @@ export const SingleAmountRecord = M.and(
  * @param {Baggage} baggage
  */
 export const start = async (zcf, privateArgs, baggage) => {
-  const { chainHub, orchestrate, zone } = provideOrchestration(
+  const { chainHub, orchestrate, vowTools, zone } = provideOrchestration(
     zcf,
     baggage,
     privateArgs,
     privateArgs.marshaller,
   );
+  const agoricNamesTools = makeResumableAgoricNamesHack(zone, {
+    agoricNames: privateArgs.agoricNames,
+    vowTools,
+  });
 
-  /** @type {import('../orchestration-api.js').OrchestrationAccount<any>} */
-  let contractAccount;
-
-  const findBrandInVBank = async brand => {
-    const assets = await E(
-      // XXX heapVowE
-      /** @type {Promise<Promise<NameHub<VBankAssetDetail>>>} */ (
-        E(privateArgs.agoricNames).lookup('vbankAsset')
-      ),
-    ).values();
-    const it = assets.find(a => a.brand === brand);
-    if (!it) {
-      throw Fail`brand ${brand} not in agoricNames.vbankAsset`;
-    }
-    return it;
-  };
+  /** @type {{ account: OrchestrationAccount<any> | undefined }} */
+  const contractState = makeStateRecord({ account: undefined });
 
   /** @type {OfferHandler} */
   const sendIt = orchestrate(
     'sendIt',
-    { zcf },
+    { zcf, agoricNamesTools, contractState },
     // eslint-disable-next-line no-shadow -- this `zcf` is enclosed in a membrane
-    async (orch, { zcf }, 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 findBrandInVBank(amt.brand);
-      const chain = await orch.getChain(chainName);
-
-      // FIXME ok to use a heap var crossing the membrane scope this way?
-      if (!contractAccount) {
-        const agoricChain = await orch.getChain('agoric');
-        // XXX when() until membrane
-        contractAccount = await E.when(agoricChain.makeAccount());
-        console.log('contractAccount', contractAccount);
-      }
-
-      // XXX when() until membrane
-      const info = await E.when(chain.getChainInfo());
-      console.log('info', info);
-      const { chainId } = info;
-      assert(typeof chainId === 'string', 'bad chainId');
-      const { [kw]: pmtP } = await withdrawFromSeat(zcf, seat, give);
-      await E.when(pmtP, pmt => contractAccount.deposit(pmt));
-      await contractAccount.transfer(
-        { denom, value: amt.value },
-        {
-          address: destAddr,
-          addressEncoding: 'bech32',
-          chainId,
-        },
-      );
-    },
+    sendItFn,
   );
 
   const publicFacet = zone.exo(

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

@@ -1,12 +1,3 @@
-/**
- * @import {Orchestrator, IcaAccount, CosmosValidatorAddress} from '../types.js'
- * @import {TimerService} from '@agoric/time';
- * @import {LocalChain} from '@agoric/vats/src/localchain.js';
- * @import {Remote} from '@agoric/internal';
- * @import {OrchestrationService} from '../service.js';
- * @import {Baggage} from '@agoric/vat-data'
- * @import {NameHub} from '@agoric/vats';
- */
 /** @type {ContractMeta<typeof start>} */
 export const meta: ContractMeta<typeof start>;
 export function makeNatAmountShape(brand: Brand, min?: bigint | undefined): {

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

@@ -1 +1 @@
-{"version":3,"file":"swapExample.contract.d.ts","sourceRoot":"","sources":["swapExample.contract.js"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AAEH,yCAAyC;AACzC,mBADW,YAAY,CAAC,OAAO,KAAK,CAAC,CAWnC;AASK,0CAHI,KAAK;;;EAIsC;AAc/C,2BAXI,GAAG,eACH;IACV,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;IACjC,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,UAAc,EAAE,UAAU,CAAC;CACxB,WACO,OAAO;;;oBA+BD,MAAM,CAAC,KAAK,CAAC;uBAAa,sBAAsB;;;;oBAAhD,MAAM,CAAC,KAAK,CAAC;uBAAa,sBAAsB;;;GAsEhE;6BAzIyB,cAAc;4BAHf,kBAAkB;gCADd,gCAAgC;0CAEtB,eAAe;kCAHvB,cAAc;6BAInB,kBAAkB;4CALuB,aAAa"}
+{"version":3,"file":"swapExample.contract.d.ts","sourceRoot":"","sources":["swapExample.contract.js"],"names":[],"mappings":"AAuEA,yCAAyC;AACzC,mBADW,YAAY,CAAC,OAAO,KAAK,CAAC,CAWnC;AASK,0CAHI,KAAK;;;EAIsC;AAc/C,2BAXI,GAAG,eACH;IACV,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;IACjC,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,UAAc,EAAE,UAAU,CAAC;CACxB,WACO,OAAO;;;oBA+BD,MAAM,CAAC,KAAK,CAAC;uBAAa,sBAAsB;;;;oBAAhD,MAAM,CAAC,KAAK,CAAC;uBAAa,sBAAsB;;;GAsBhE;6BA5IyB,cAAc;4BAHf,kBAAkB;gCADd,gCAAgC;0CAEtB,eAAe;kCAHvB,cAAc;6BAInB,kBAAkB;4CALuB,aAAa"}

package/src/examples/swapExample.contract.js

@@ -18,6 +18,57 @@ import { provideOrchestration } from '../utils/start-helper.js';
  * @import {NameHub} from '@agoric/vats';
  */
 
+/**
+ * @param {Orchestrator} orch
+ * @param {object} ctx
+ * @param {ZCF} ctx.zcf
+ * @param {ZCFSeat} seat
+ * @param {object} offerArgs
+ * @param {Amount<'nat'>} offerArgs.staked
+ * @param {CosmosValidatorAddress} offerArgs.validator
+ */
+const stackAndSwapFn = async (orch, { zcf }, seat, offerArgs) => {
+  const { give } = seat.getProposal();
+
+  const omni = await orch.getChain('omniflixhub');
+  const agoric = await orch.getChain('agoric');
+
+  const [omniAccount, localAccount] = await Promise.all([
+    // XXX when() until membrane
+    heapVowTools.when(omni.makeAccount()),
+    // XXX when() until membrane
+    heapVowTools.when(agoric.makeAccount()),
+  ]);
+
+  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),
+    ),
+  );
+  seat.exit();
+
+  // build swap instructions with orcUtils library
+  const transferMsg = orcUtils.makeOsmosisSwap({
+    destChain: 'omniflixhub',
+    destAddress: omniAddress,
+    amountIn: give.Stable,
+    brandOut: /** @type {any} */ ('FIXME'),
+    slippage: 0.03,
+  });
+
+  await localAccount
+    .transferSteps(give.Stable, transferMsg)
+    .then(_txResult =>
+      omniAccount.delegate(offerArgs.validator, offerArgs.staked),
+    )
+    .catch(e => console.error(e));
+};
+
 /** @type {ContractMeta<typeof start>} */
 export const meta = {
   privateArgsShape: {
@@ -85,55 +136,7 @@ export const start = async (zcf, privateArgs, baggage) => {
    *   { staked: Amount<'nat'>; validator: CosmosValidatorAddress }
    * >}
    */
-  const swapAndStakeHandler = orchestrate(
-    'LSTTia',
-    { zcf },
-    // eslint-disable-next-line no-shadow -- this `zcf` is enclosed in a membrane
-    async (/** @type {Orchestrator} */ orch, { zcf }, seat, offerArgs) => {
-      const { give } = seat.getProposal();
-
-      const omni = await orch.getChain('omniflixhub');
-      const agoric = await orch.getChain('agoric');
-
-      const [omniAccount, localAccount] = await Promise.all([
-        // XXX when() until membrane
-        heapVowTools.when(omni.makeAccount()),
-        // XXX when() until membrane
-        heapVowTools.when(agoric.makeAccount()),
-      ]);
-
-      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),
-        ),
-      );
-      seat.exit();
-
-      // build swap instructions with orcUtils library
-      const transferMsg = orcUtils.makeOsmosisSwap({
-        destChain: 'omniflixhub',
-        destAddress: omniAddress,
-        amountIn: give.Stable,
-        brandOut: /** @type {any} */ ('FIXME'),
-        slippage: 0.03,
-      });
-
-      await localAccount
-        .transferSteps(give.Stable, transferMsg)
-        .then(_txResult =>
-          omniAccount.delegate(offerArgs.validator, offerArgs.staked),
-        )
-        .catch(e => console.error(e));
-
-      // XXX close localAccount?
-      // return continuing inv since this is an offer?
-    },
-  );
+  const swapAndStakeHandler = orchestrate('LSTTia', { zcf }, stackAndSwapFn);
 
   const makeSwapAndStakeInvitation = () =>
     zcf.makeInvitation(

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

@@ -1 +1 @@
-{"version":3,"file":"unbondExample.contract.d.ts","sourceRoot":"","sources":["unbondExample.contract.js"],"names":[],"mappings":"AA0BO,2BAXI,GAAG,eACH;IACV,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;IACjC,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,UAAc,EAAE,UAAU,CAAC;IAC3B,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;CACpC,WACO,OAAO;;;;;;GA0EjB;6BAzFyB,cAAc;4BACf,kBAAkB;gCAFd,gCAAgC;0CAGtB,eAAe;kCALvB,cAAc;6BACnB,kBAAkB"}
+{"version":3,"file":"unbondExample.contract.d.ts","sourceRoot":"","sources":["unbondExample.contract.js"],"names":[],"mappings":"AAwDO,2BAXI,GAAG,eACH;IACV,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;IACjC,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,UAAc,EAAE,UAAU,CAAC;IAC3B,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;CACpC,WACO,OAAO;;;;;;GAkDjB;6BA/FyB,cAAc;4BACf,kBAAkB;gCAFd,gCAAgC;0CAGtB,eAAe;kCALvB,cAAc;6BACnB,kBAAkB"}

package/src/examples/unbondExample.contract.js

@@ -12,6 +12,36 @@ import { provideOrchestration } from '../utils/start-helper.js';
  * @import {OrchestrationService} from '../service.js';
  */
 
+/**
+ * @param {Orchestrator} orch
+ * @param {object} ctx
+ * @param {ZCF} ctx.zcf
+ * @param {ZCFSeat} _seat
+ * @param {undefined} _offerArgs
+ */
+const unbondAndLiquidStakeFn = async (orch, { zcf }, _seat, _offerArgs) => {
+  console.log('zcf within the membrane', zcf);
+  // We would actually alreaady have the account from the orchestrator
+  // ??? could these be passed in? It would reduce the size of this handler,
+  // keeping it focused on long-running operations.
+  const omni = await orch.getChain('omniflixhub');
+  const omniAccount = await omni.makeAccount();
+
+  // TODO implement these
+  // const delegations = await celestiaAccount.getDelegations();
+  // // wait for the undelegations to be complete (may take weeks)
+  // await celestiaAccount.undelegate(delegations);
+  // ??? should this be synchronous? depends on how names are resolved.
+  const stride = await orch.getChain('stride');
+  const strideAccount = await stride.makeAccount();
+
+  // TODO the `TIA` string actually needs to be the Brand from AgoricNames
+  // const tiaAmt = await celestiaAccount.getBalance('TIA');
+  // await celestiaAccount.transfer(tiaAmt, strideAccount.getAddress());
+  // await strideAccount.liquidStake(tiaAmt);
+  console.log(omniAccount, strideAccount);
+};
+
 /**
  * @param {ZCF} zcf
  * @param {{
@@ -51,31 +81,7 @@ export const start = async (zcf, privateArgs, baggage) => {
   const unbondAndLiquidStake = orchestrate(
     'LSTTia',
     { zcf },
-    // eslint-disable-next-line no-shadow -- this `zcf` is enclosed in a membrane
-    async (/** @type {Orchestrator} */ orch, { zcf }, _seat, _offerArgs) => {
-      console.log('zcf within the membrane', zcf);
-      // We would actually alreaady have the account from the orchestrator
-      // ??? could these be passed in? It would reduce the size of this handler,
-      // keeping it focused on long-running operations.
-      const omni = await orch.getChain('omniflixhub');
-      const omniAccount = await omni.makeAccount();
-
-      // TODO implement these
-      // const delegations = await celestiaAccount.getDelegations();
-      // // wait for the undelegations to be complete (may take weeks)
-      // await celestiaAccount.undelegate(delegations);
-
-      // ??? should this be synchronous? depends on how names are resolved.
-      const stride = await orch.getChain('stride');
-      const strideAccount = await stride.makeAccount();
-
-      // TODO the `TIA` string actually needs to be the Brand from AgoricNames
-      // const tiaAmt = await celestiaAccount.getBalance('TIA');
-      // await celestiaAccount.transfer(tiaAmt, strideAccount.getAddress());
-
-      // await strideAccount.liquidStake(tiaAmt);
-      console.log(omniAccount, strideAccount);
-    },
+    unbondAndLiquidStakeFn,
   );
 
   const makeUnbondAndLiquidStakeInvitation = () =>

package/src/exos/agoric-names-tools.d.ts

@@ -0,0 +1,27 @@
+export function makeResumableAgoricNamesHack(zone: Zone, { agoricNames, vowTools: { watch, asVow } }: {
+    agoricNames: Remote<NameHub>;
+    vowTools: VowTools;
+}): import("@endo/exo").Guarded<{
+    /** @param {...string} args */
+    lookup(...args: string[]): Vow<any>;
+    /**
+     * Look up asset info, like denom, in agoricNames.vbankAsset using a
+     * Brand.
+     *
+     * Caches the query to agoricNames in the first call. Subsequent lookups
+     * are via cache unless a refetch is specified or a brand is not found.
+     *
+     * @param {Brand<'nat'>} brand
+     * @param {boolean} [refetch] if true, will invalidate the cache
+     * @returns {Vow<AssetInfo>}
+     */
+    findBrandInVBank(brand: Brand<"nat">, refetch?: boolean | undefined): Vow<AssetInfo>;
+}>;
+export type AgNamesTools = ReturnType<typeof makeResumableAgoricNamesHack>;
+import type { Zone } from '@agoric/zone';
+import type { NameHub } from '@agoric/vats';
+import type { Remote } from '@agoric/internal';
+import type { VowTools } from '@agoric/vow';
+import type { Vow } from '@agoric/vow';
+import type { AssetInfo } from '@agoric/vats/src/vat-bank.js';
+//# sourceMappingURL=agoric-names-tools.d.ts.map

package/src/exos/agoric-names-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agoric-names-tools.d.ts","sourceRoot":"","sources":["agoric-names-tools.js"],"names":[],"mappings":"AA4BO,mDAHI,IAAI,+CACJ;IAAE,WAAW,EAAE,OAAO,OAAO,CAAC,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAA;CAAE;IA8CvD,8BAA8B;oBAAf,MAAM,EAAA;IAIrB;;;;;;;;;;OAUG;4BAHQ,KAAK,CAAC,KAAK,CAAC,kCAEV,IAAI,SAAS,CAAC;GAsBlC;2BACa,UAAU,CAAC,OAAO,4BAA4B,CAAC;0BAhGtC,cAAc;6BAJX,cAAc;4BAEf,kBAAkB;8BACX,aAAa;yBAAb,aAAa;+BAFjB,8BAA8B"}

package/src/exos/agoric-names-tools.js

@@ -0,0 +1,109 @@
+import { VowShape } from '@agoric/vow';
+import { E } from '@endo/far';
+import { M, makeCopyMap } from '@endo/patterns';
+import { BrandShape } from '@agoric/ertp';
+
+const { Fail } = assert;
+
+/**
+ * @import {NameHub} from '@agoric/vats';
+ * @import {AssetInfo} from '@agoric/vats/src/vat-bank.js';
+ * @import {Remote} from '@agoric/internal';
+ * @import {Vow, VowTools} from '@agoric/vow';
+ * @import {Zone} from '@agoric/zone';
+ */
+
+/**
+ * Perform remote calls to agoricNames in membrane-friendly way. This is an
+ * interim approach until https://github.com/Agoric/agoric-sdk/issues/9541,
+ * https://github.com/Agoric/agoric-sdk/pull/9322, or
+ * https://github.com/Agoric/agoric-sdk/pull/9519.
+ *
+ * XXX only works once per zone.
+ *
+ * XXX consider exposing `has`, `entries`, `keys`, `values` from `NameHub`
+ *
+ * @param {Zone} zone
+ * @param {{ agoricNames: Remote<NameHub>; vowTools: VowTools }} powers
+ */
+export const makeResumableAgoricNamesHack = (
+  zone,
+  { agoricNames, vowTools: { watch, asVow } },
+) => {
+  const makeResumableAgoricNamesHackKit = zone.exoClassKit(
+    'ResumableAgoricNamesHack',
+    {
+      public: M.interface('ResumableAgoricNamesHackI', {
+        lookup: M.call().rest(M.arrayOf(M.string())).returns(VowShape),
+        findBrandInVBank: M.call(BrandShape)
+          .optional(M.boolean())
+          .returns(VowShape),
+      }),
+      vbankAssetEntriesWatcher: M.interface('vbankAssetEntriesWatcher', {
+        onFulfilled: M.call(M.arrayOf(M.record()))
+          .optional({ brand: BrandShape })
+          .returns(VowShape),
+      }),
+    },
+    () => ({
+      vbankAssetsByBrand: zone.mapStore('vbankAssetsByBrand', {
+        keyShape: BrandShape,
+        valueShape: M.any(),
+      }),
+    }),
+    {
+      vbankAssetEntriesWatcher: {
+        /**
+         * @param {AssetInfo[]} assets
+         * @param {{ brand: Brand<'nat'> }} ctx
+         */
+        onFulfilled(assets, { brand }) {
+          return asVow(() => {
+            const { vbankAssetsByBrand } = this.state;
+            vbankAssetsByBrand.addAll(
+              makeCopyMap(assets.map(a => [a.brand, a])),
+            );
+            vbankAssetsByBrand.has(brand) ||
+              Fail`brand ${brand} not in agoricNames.vbankAsset`;
+            return vbankAssetsByBrand.get(brand);
+          });
+        },
+      },
+      public: {
+        /** @param {...string} args */
+        lookup(...args) {
+          return watch(E(agoricNames).lookup(...args));
+        },
+        /**
+         * Look up asset info, like denom, in agoricNames.vbankAsset using a
+         * Brand.
+         *
+         * Caches the query to agoricNames in the first call. Subsequent lookups
+         * are via cache unless a refetch is specified or a brand is not found.
+         *
+         * @param {Brand<'nat'>} brand
+         * @param {boolean} [refetch] if true, will invalidate the cache
+         * @returns {Vow<AssetInfo>}
+         */
+        findBrandInVBank(brand, refetch) {
+          return asVow(() => {
+            const { vbankAssetsByBrand } = this.state;
+            if (vbankAssetsByBrand.has(brand) && !refetch) {
+              return vbankAssetsByBrand.get(brand);
+            }
+            const vbankAssetNameHubP = E(agoricNames).lookup('vbankAsset');
+            const vbankAssetEntriesP = E(vbankAssetNameHubP).values();
+            return watch(
+              vbankAssetEntriesP,
+              this.facets.vbankAssetEntriesWatcher,
+              { brand },
+            );
+          });
+        },
+      },
+    },
+  );
+  // XXX only works once per zone.
+  return makeResumableAgoricNamesHackKit().public;
+};
+/** @typedef {ReturnType<typeof makeResumableAgoricNamesHack>} AgNamesTools */

package/src/facade.d.ts

@@ -15,20 +15,31 @@ export function makeOrchestrationFacade({ zone, timerService, zcf, storageNode,
     asyncFlowTools: AsyncFlowTools;
 }): {
     /**
-     * @template Return
-     * @template Context
-     * @template {any[]} Args
+     * @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 {Context} ctx - values to pass through the async flow membrane
+     * @param {HostContext} hostCtx - values to pass through the async flow
+     *   membrane
      * @param {(
-     *   orc: Orchestrator,
-     *   ctx2: Context,
-     *   ...args: Args
-     * ) => Promise<Return>} fn
-     * @returns {(...args: Args) => Promise<Return>}
+     *   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<Return, Context, Args extends any[]>(durableName: string, ctx: Context, fn: (orc: Orchestrator, ctx2: Context, ...args: Args) => Promise<Return>): (...args: Args) => Promise<Return>;
+    orchestrate<GuestReturn, HostReturn, GuestContext, HostContext, GuestArgs extends any[], HostArgs extends any[]>(durableName: string, hostCtx: HostContext, guestFn: (guestOrc: Orchestrator, guestCtx: GuestContext, ...args: GuestArgs) => Promise<GuestReturn>): (...args: HostArgs) => Promise<HostReturn>;
+    adminAsyncFlow: import("@endo/exo").Guarded<{
+        getFailures(): import("@endo/patterns").CopyMap<any, import("@endo/pass-style").Passable>;
+        wakeAll(): void;
+        getFlowForOutcomeVow(outcomeVow: any): any;
+    }>;
 };
 export type OrchestrationFacade = ReturnType<typeof makeOrchestrationFacade>;
 import type { Zone } from '@agoric/zone';

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,oBAAoB,CAAC,CAAC;IACvD,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,QAAY,EAAE,OAAO,qBAAqB,EAAE,QAAQ,CAAC;IACrD,gCAAoC,EAAE,gCAAgC,CAAC;IACvE,eAAmB,EAAE,eAAe,CAAC;IACrC,8BAAkC,EAAE,GAAG,CAAC;IACxC,oBAAwB,EAAE,oBAAoB,CAAC;IAC/C,qBAAyB,EAAE,qBAAqB,CAAC;IACjD,QAAY,EAAE,QAAQ,CAAC;IACvB,cAAkB,EAAE,cAAc,CAAC;CAChC;IA+CA;;;;;;;;;;;;;OAaG;gBAZU,MAAM,EACN,OAAO,EACC,IAAI,SAAX,GAAG,EAAG,eACT,MAAM,OAEN,OAAO,MACP,CACV,GAAO,EAAE,YAAY,EACrB,IAAQ,EAAE,OAAO,EACjB,GAAO,IAAI,EAAE,IAAI,KACV,OAAO,CAAC,MAAM,CAAC,GACV,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC;EAQlD;kCAEa,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BAnGjC,cAAc;kCAEN,cAAc;4BAIpB,kBAAkB;0CACJ,cAAc;gCAHxB,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":"AAwCO,yPAjBI;IACV,IAAQ,EAAE,IAAI,CAAC;IACf,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,GAAO,EAAE,GAAG,CAAC;IACb,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,QAAY,EAAE,OAAO,qBAAqB,EAAE,QAAQ,CAAC;IACrD,gCAAoC,EAAE,gCAAgC,CAAC;IACvE,eAAmB,EAAE,eAAe,CAAC;IACrC,8BAAkC,EAAE,GAAG,CAAC;IACxC,oBAAwB,EAAE,oBAAoB,CAAC;IAC/C,qBAAyB,EAAE,qBAAqB,CAAC;IACjD,QAAY,EAAE,QAAQ,CAAC;IACvB,cAAkB,EAAE,cAAc,CAAC;CAChC;IAmDA;;;;;;;;;;;;;;;;;;;OAmBG;gBAlBU,WAAW,EACX,UAAU,EACV,YAAY,EACZ,WAAW,EACH,SAAS,SAAhB,GAAG,EAAG,EACC,QAAQ,SAAf,GAAG,EAAG,eACT,MAAM,WAEN,WAAW,WAEX,CACV,QAAY,EAAE,YAAY,EAC1B,QAAY,EAAE,YAAY,EAC1B,GAAO,IAAI,EAAE,SAAS,KACf,OAAO,CAAC,WAAW,CAAC,GACf,CAAC,GAAG,IAAI,EAAE,QAAQ,KAAK,OAAO,CAAC,UAAU,CAAC;;;;;;EAwB1D;kCAEa,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BA3HjC,cAAc;kCAEN,cAAc;4BAIpB,kBAAkB;0CACJ,cAAc;gCAHxB,gCAAgC;sDAOV,uCAAuC;qCAN3C,6CAA6C;0CAIrD,8BAA8B;2CAC7B,+BAA+B;8BATvC,aAAa;oCAFZ,oBAAoB;kCASsD,YAAY"}

package/src/facade.js

@@ -82,26 +82,50 @@ export const makeOrchestrationFacade = ({
   });
   const makeOrchestrator = pickFacet(makeOrchestratorKit, 'orchestrator');
 
+  const { prepareEndowment, asyncFlow, adminAsyncFlow } = asyncFlowTools;
+
+  const { when } = vowTools;
+
   return {
     /**
-     * @template Return
-     * @template Context
-     * @template {any[]} Args
+     * @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 {Context} ctx - values to pass through the async flow membrane
+     * @param {HostContext} hostCtx - values to pass through the async flow
+     *   membrane
      * @param {(
-     *   orc: Orchestrator,
-     *   ctx2: Context,
-     *   ...args: Args
-     * ) => Promise<Return>} fn
-     * @returns {(...args: Args) => Promise<Return>}
+     *   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, ctx, fn) {
-      const orc = makeOrchestrator();
+    orchestrate(durableName, hostCtx, guestFn) {
+      const subZone = zone.subZone(durableName);
+
+      const hostOrc = makeOrchestrator();
+
+      const [wrappedOrc, wrappedCtx] = prepareEndowment(subZone, 'endowments', [
+        hostOrc,
+        hostCtx,
+      ]);
+
+      const hostFn = asyncFlow(subZone, 'asyncFlow', guestFn);
 
-      return async (...args) => vowTools.when(fn(orc, ctx, ...args));
+      const orcFn = (...args) =>
+        // TODO remove the `when` after fixing the return type
+        // to `Vow<HostReturn>`
+        when(hostFn(wrappedOrc, wrappedCtx, ...args));
+      return harden(orcFn);
     },
+    adminAsyncFlow,
   };
 };
 harden(makeOrchestrationFacade);

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

@@ -10,8 +10,20 @@ export function provideOrchestration(zcf: ZCF, baggage: Baggage, remotePowers: O
         }): import("@agoric/vow").Vow<import("../cosmos-api.js").IBCConnectionInfo>;
         getChainsAndConnection<C1 extends string, C2 extends string>(chainName1: C1, chainName2: C2): import("@agoric/vow").Vow<[ActualChainInfo<C1>, ActualChainInfo<C2>, import("../cosmos-api.js").IBCConnectionInfo]>;
     }>;
+    vowTools: {
+        when: <T, TResult1 = import("@agoric/vow").EUnwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").EUnwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
+        watch: <T = any, TResult1 = T, TResult2 = never, C extends any[] = any[]>(specimenP: import("@agoric/vow").ERef<T | import("@agoric/vow").Vow<T>>, watcher?: import("@agoric/vow").Watcher<T, TResult1, TResult2, C> | undefined, ...watcherArgs: C) => import("@agoric/vow").Vow<Exclude<TResult1, void> | Exclude<TResult2, void> extends never ? TResult1 : Exclude<TResult1, void> | Exclude<TResult2, void>>;
+        makeVowKit: <T>() => import("@agoric/vow").VowKit<T>;
+        allVows: (vows: unknown[]) => import("@agoric/vow").Vow<any[]>;
+        asVow: <T extends unknown>(fn: (...args: any[]) => import("@agoric/vow").Vow<Awaited<T>> | Awaited<T>) => import("@agoric/vow").Vow<Awaited<T>>;
+    };
     zone: import("@agoric/base-zone").Zone;
-    orchestrate<Return, Context, Args extends any[]>(durableName: string, ctx: Context, fn: (orc: import("../orchestration-api.js").Orchestrator, ctx2: Context, ...args: Args) => Promise<Return>): (...args: Args) => Promise<Return>;
+    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;
+    }>;
 };
 export type OrchestrationPowers = {
     localchain: Remote<LocalChain>;

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

@@ -1 +1 @@
-{"version":3,"file":"start-helper.d.ts","sourceRoot":"","sources":["start-helper.js"],"names":[],"mappings":"AAwCO,0CALI,GAAG,WACH,OAAO,gBACP,mBAAmB,cACnB,UAAU;;;;;;;;;;;;;iKA4DT,GAAa,kCAED,GACxB;EAKC;kCApFY;IACZ,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;CAC9B;6BAbsB,kBAAkB;gCAFf,gCAAgC;4BAIpC,aAAa;0CACC,eAAe;kCAJX,cAAc;6BAE/B,cAAc"}
+{"version":3,"file":"start-helper.d.ts","sourceRoot":"","sources":["start-helper.js"],"names":[],"mappings":"AAwCO,0CALI,GAAG,WACH,OAAO,gBACP,mBAAmB,cACnB,UAAU;;;;;;;;;;;;;;;;;wCAyCjB,GAAF;;;4PA6BqB,GACjB,4CAA4E,GAAG;;;;;;EAFpF;kCArFY;IACZ,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;CAC9B;6BAbsB,kBAAkB;gCAFf,gCAAgC;4BAIpC,aAAa;0CACC,eAAe;kCAJX,cAAc;6BAE/B,cAAc"}

package/src/utils/start-helper.js

@@ -45,8 +45,9 @@ export const provideOrchestration = (
   marshaller,
 ) => {
   const zone = makeDurableZone(baggage);
+  const { agoricNames, timerService } = remotePowers;
 
-  const chainHub = makeChainHub(remotePowers.agoricNames);
+  const chainHub = makeChainHub(agoricNames);
 
   const vowTools = prepareVowTools(zone.subZone('vows'));
 
@@ -55,7 +56,7 @@ export const provideOrchestration = (
     zone,
     makeRecorderKit,
     zcf,
-    remotePowers.timerService,
+    timerService,
     vowTools,
     chainHub,
   );
@@ -103,6 +104,6 @@ export const provideOrchestration = (
     vowTools,
     ...remotePowers,
   });
-  return { ...facade, chainHub, zone };
+  return { ...facade, chainHub, vowTools, zone };
 };
 harden(provideOrchestration);