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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/orchestration",
-  "version": "0.1.1-dev-0006934.0+0006934",
+  "version": "0.1.1-dev-12ce494.0+12ce494",
   "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-0006934.0+0006934",
-    "@agoric/cosmic-proto": "0.4.1-dev-0006934.0+0006934",
-    "@agoric/ertp": "0.16.3-dev-0006934.0+0006934",
-    "@agoric/internal": "0.3.3-dev-0006934.0+0006934",
-    "@agoric/network": "0.1.1-dev-0006934.0+0006934",
-    "@agoric/notifier": "0.6.3-dev-0006934.0+0006934",
-    "@agoric/store": "0.9.3-dev-0006934.0+0006934",
-    "@agoric/time": "0.3.3-dev-0006934.0+0006934",
-    "@agoric/vat-data": "0.5.3-dev-0006934.0+0006934",
-    "@agoric/vats": "0.15.2-dev-0006934.0+0006934",
-    "@agoric/vow": "0.1.1-dev-0006934.0+0006934",
-    "@agoric/zoe": "0.26.3-dev-0006934.0+0006934",
-    "@agoric/zone": "0.2.3-dev-0006934.0+0006934",
+    "@agoric/async-flow": "0.1.1-dev-12ce494.0+12ce494",
+    "@agoric/cosmic-proto": "0.4.1-dev-12ce494.0+12ce494",
+    "@agoric/ertp": "0.16.3-dev-12ce494.0+12ce494",
+    "@agoric/internal": "0.3.3-dev-12ce494.0+12ce494",
+    "@agoric/network": "0.1.1-dev-12ce494.0+12ce494",
+    "@agoric/notifier": "0.6.3-dev-12ce494.0+12ce494",
+    "@agoric/store": "0.9.3-dev-12ce494.0+12ce494",
+    "@agoric/time": "0.3.3-dev-12ce494.0+12ce494",
+    "@agoric/vat-data": "0.5.3-dev-12ce494.0+12ce494",
+    "@agoric/vats": "0.15.2-dev-12ce494.0+12ce494",
+    "@agoric/vow": "0.1.1-dev-12ce494.0+12ce494",
+    "@agoric/zoe": "0.26.3-dev-12ce494.0+12ce494",
+    "@agoric/zone": "0.2.3-dev-12ce494.0+12ce494",
     "@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-0006934.0+0006934",
+    "@agoric/swingset-liveslots": "0.10.3-dev-12ce494.0+12ce494",
     "@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": "000693442f821c1fcea007a2df740733b1f75ebe"
+  "gitHead": "12ce49423c9afe6eb2396e7cac79b7f2f003cbb0"
 }

package/src/examples/basic-flows.contract.d.ts

@@ -0,0 +1,11 @@
+export function start(zcf: ZCF, privateArgs: OrchestrationPowers & {
+    marshaller: Marshaller;
+}, baggage: Baggage): Promise<{
+    publicFacet: import("@endo/exo").Guarded<{
+        makeOrchAccountInvitation(): Promise<Invitation<unknown, never>>;
+    }>;
+}>;
+export type BasicFlowsSF = typeof start;
+import type { OrchestrationPowers } from '../utils/start-helper.js';
+import type { Baggage } from '@agoric/vat-data';
+//# sourceMappingURL=basic-flows.contract.d.ts.map

package/src/examples/basic-flows.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic-flows.contract.d.ts","sourceRoot":"","sources":["basic-flows.contract.js"],"names":[],"mappings":"AAsCO,2BANI,GAAG,eACH,mBAAmB,GAAG;IAChC,UAAc,EAAE,UAAU,CAAC;CACxB,WACO,OAAO;;;;GAiCjB;2BAEa,OAAO,KAAK;yCA5DY,0BAA0B;6BAFtC,kBAAkB"}

package/src/examples/basic-flows.contract.js

@@ -0,0 +1,72 @@
+/**
+ * @file Primarily a testing fixture, but also serves as an example of how to
+ *   leverage basic functionality of the Orchestration API with async-flow.
+ */
+import { InvitationShape } from '@agoric/zoe/src/typeGuards.js';
+import { M, mustMatch } from '@endo/patterns';
+import { provideOrchestration } from '../utils/start-helper.js';
+
+/**
+ * @import {Baggage} from '@agoric/vat-data';
+ * @import {Orchestrator} from '@agoric/orchestration';
+ * @import {OrchestrationPowers} from '../utils/start-helper.js';
+ */
+
+/**
+ * Create an account on a Cosmos chain and return a continuing offer with
+ * invitations makers for Delegate, WithdrawRewards, Transfer, etc.
+ *
+ * @param {Orchestrator} orch
+ * @param {undefined} _ctx
+ * @param {ZCFSeat} seat
+ * @param {{ chainName: string }} offerArgs
+ */
+const makeOrchAccountHandler = async (orch, _ctx, seat, { chainName }) => {
+  seat.exit(); // no funds exchanged
+  mustMatch(chainName, M.string());
+  const remoteChain = await orch.getChain(chainName);
+  const cosmosAccount = await remoteChain.makeAccount();
+  return cosmosAccount.asContinuingOffer();
+};
+
+/**
+ * @param {ZCF} zcf
+ * @param {OrchestrationPowers & {
+ *   marshaller: Marshaller;
+ * }} privateArgs
+ * @param {Baggage} baggage
+ */
+export const start = async (zcf, privateArgs, baggage) => {
+  const { orchestrate, zone } = provideOrchestration(
+    zcf,
+    baggage,
+    privateArgs,
+    privateArgs.marshaller,
+  );
+
+  /** @type {OfferHandler} */
+  const makeOrchAccount = orchestrate(
+    'makeOrchAccount',
+    undefined,
+    makeOrchAccountHandler,
+  );
+
+  const publicFacet = zone.exo(
+    'Basic Flows Public Facet',
+    M.interface('Basic Flows PF', {
+      makeOrchAccountInvitation: M.callWhen().returns(InvitationShape),
+    }),
+    {
+      makeOrchAccountInvitation() {
+        return zcf.makeInvitation(
+          makeOrchAccount,
+          'Make an Orchestration Account',
+        );
+      },
+    },
+  );
+
+  return { publicFacet };
+};
+
+/** @typedef {typeof start} BasicFlowsSF */

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/stakeBld.contract.d.ts

@@ -9,12 +9,12 @@ export function start(zcf: ZCF, privateArgs: {
         /**
          * Invitation to make an account, initialized with the give's BLD
          */
-        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 start(zcf: ZCF, privateArgs: {
                 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 start(zcf: ZCF, privateArgs: {
                 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>>;
@@ -74,12 +76,12 @@ export function start(zcf: ZCF, privateArgs: {
         /**
          * Invitation to make an account, without any funds
          */
-        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<{
@@ -87,16 +89,17 @@ export function start(zcf: ZCF, privateArgs: {
                 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>>;
@@ -111,7 +114,7 @@ export function start(zcf: ZCF, privateArgs: {
                 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>>;
     }>;
 }>;
 import type { NameHub } from '@agoric/vats';

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

@@ -1 +1 @@
-{"version":3,"file":"stakeBld.contract.d.ts","sourceRoot":"","sources":["stakeBld.contract.js"],"names":[],"mappings":"AAkCO,2BAVI,GAAG,eACH;IACV,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;IACjC,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,UAAc,EAAE,UAAU,CAAC;IAC3B,WAAe,EAAE,WAAW,CAAC;IAC7B,YAAgB,EAAE,YAAY,CAAC;CAC5B,WACO,OAAO,kBAAkB,EAAE,OAAO;;QAiDvC;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA8BH;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiBR;6BArHyB,cAAc;4BACf,kBAAkB;gCAEd,gCAAgC;kCAD9B,cAAc"}
+{"version":3,"file":"stakeBld.contract.d.ts","sourceRoot":"","sources":["stakeBld.contract.js"],"names":[],"mappings":"AAkCO,2BAVI,GAAG,eACH;IACV,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;IACjC,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,UAAc,EAAE,UAAU,CAAC;IAC3B,WAAe,EAAE,WAAW,CAAC;IAC7B,YAAgB,EAAE,YAAY,CAAC;CAC5B,WACO,OAAO,kBAAkB,EAAE,OAAO;;QAiDvC;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA0BH;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAaR;6BA7GyB,cAAc;4BACf,kBAAkB;gCAEd,gCAAgC;kCAD9B,cAAc"}

package/src/examples/stakeBld.contract.js

@@ -87,17 +87,13 @@ export const start = async (zcf, privateArgs, baggage) => {
           async seat => {
             const { give } = seat.getProposal();
             trace('makeStakeBldInvitation', give);
-            const { holder, invitationMakers } = await makeLocalAccountKit();
+            const { holder } = await makeLocalAccountKit();
             const { In } = await deeplyFulfilled(
               withdrawFromSeat(zcf, seat, give),
             );
             await E(holder).deposit(In);
             seat.exit();
-            return harden({
-              publicSubscribers: holder.getPublicTopics(),
-              invitationMakers,
-              account: holder,
-            });
+            return holder.asContinuingOffer();
           },
           'wantStake',
           undefined,
@@ -118,12 +114,8 @@ export const start = async (zcf, privateArgs, baggage) => {
         trace('makeCreateAccountInvitation');
         return zcf.makeInvitation(async seat => {
           seat.exit();
-          const { holder, invitationMakers } = await makeLocalAccountKit();
-          return harden({
-            publicSubscribers: holder.getPublicTopics(),
-            invitationMakers,
-            account: holder,
-          });
+          const { holder } = await makeLocalAccountKit();
+          return holder.asContinuingOffer();
         }, 'wantLocalChainAccount');
       },
     },

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

@@ -20,12 +20,12 @@ export function start(zcf: ZCF<StakeIcaTerms>, privateArgs: {
 }, baggage: 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<{
@@ -37,14 +37,14 @@ export function start(zcf: ZCF<StakeIcaTerms>, privateArgs: {
                     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>;
@@ -57,12 +57,12 @@ export function start(zcf: ZCF<StakeIcaTerms>, privateArgs: {
             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<{
@@ -74,7 +74,7 @@ export function start(zcf: ZCF<StakeIcaTerms>, privateArgs: {
                 TransferAccount(): never;
             }>;
             holder: import("@endo/exo").Guarded<any>;
-        }, undefined>>;
+        }>, undefined>>;
     }>;
 }>;
 export type StakeIcaTerms = {

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"}