@agoric/orchestration 0.2.0-upgrade-17-dev-ec448b0.0 → 0.2.0-upgrade-18-dev-b9b8db4.0

package/src/examples/send-anywhere.flows.js

@@ -1,10 +1,13 @@
 import { NonNullish } from '@agoric/internal';
+import { makeError, q } from '@endo/errors';
 import { M, mustMatch } from '@endo/patterns';
 
 /**
- * @import {GuestOf} from '@agoric/async-flow';
+ * @import {GuestInterface, GuestOf} from '@agoric/async-flow';
+ * @import {Vow} from '@agoric/vow';
+ * @import {LocalOrchestrationAccountKit} from '../exos/local-orchestration-account.js';
  * @import {ZoeTools} from '../utils/zoe-tools.js';
- * @import {Orchestrator, LocalAccountMethods, OrchestrationAccountI, OrchestrationFlow} from '../types.js';
+ * @import {Orchestrator, OrchestrationFlow, LocalAccountMethods} from '../types.js';
  */
 
 const { entries } = Object;
@@ -16,14 +19,15 @@ const { entries } = Object;
  * @satisfies {OrchestrationFlow}
  * @param {Orchestrator} orch
  * @param {object} ctx
- * @param {{ localAccount?: OrchestrationAccountI & LocalAccountMethods }} ctx.contractState
- * @param {GuestOf<ZoeTools['localTransfer']>} ctx.localTransfer
+ * @param {Promise<GuestInterface<LocalOrchestrationAccountKit['holder']>>} ctx.sharedLocalAccountP
+ * @param {GuestInterface<ZoeTools>} ctx.zoeTools
+ * @param {GuestOf<(msg: string) => Vow<void>>} ctx.log
  * @param {ZCFSeat} seat
  * @param {{ chainName: string; destAddr: string }} offerArgs
  */
 export const sendIt = async (
   orch,
-  { contractState, localTransfer },
+  { sharedLocalAccountP, log, zoeTools: { localTransfer, withdrawToSeat } },
   seat,
   offerArgs,
 ) => {
@@ -32,33 +36,49 @@ export const sendIt = async (
   // NOTE the proposal shape ensures that the `give` is a single asset
   const { give } = seat.getProposal();
   const [[_kw, amt]] = entries(give);
+  void log(`sending {${amt.value}} from ${chainName} to ${destAddr}`);
   const agoric = await orch.getChain('agoric');
   const assets = await agoric.getVBankAssetInfo();
+  void log(`got info for denoms: ${assets.map(a => a.denom).join(', ')}`);
   const { denom } = NonNullish(
     assets.find(a => a.brand === amt.brand),
     `${amt.brand} not registered in vbank`,
   );
-  const chain = await orch.getChain(chainName);
-
-  if (!contractState.localAccount) {
-    const agoricChain = await orch.getChain('agoric');
-    contractState.localAccount = await agoricChain.makeAccount();
-  }
 
+  const chain = await orch.getChain(chainName);
   const info = await chain.getChainInfo();
   const { chainId } = info;
   assert(typeof chainId === 'string', 'bad chainId');
+  void log(`got info for chain: ${chainName} ${chainId}`);
 
-  await localTransfer(seat, contractState.localAccount, give);
+  /**
+   * @type {any} XXX methods returning vows
+   *   https://github.com/Agoric/agoric-sdk/issues/9822
+   */
+  const sharedLocalAccount = await sharedLocalAccountP;
+  await localTransfer(seat, sharedLocalAccount, give);
+
+  void log(`completed transfer to localAccount`);
+
+  try {
+    await sharedLocalAccount.transfer(
+      {
+        value: destAddr,
+        encoding: 'bech32',
+        chainId,
+      },
+      { denom, value: amt.value },
+    );
+    void log(`completed transfer to ${destAddr}`);
+  } catch (e) {
+    await withdrawToSeat(sharedLocalAccount, seat, give);
+    const errorMsg = `IBC Transfer failed ${q(e)}`;
+    void log(`ERROR: ${errorMsg}`);
+    seat.exit(errorMsg);
+    throw makeError(errorMsg);
+  }
 
-  await contractState.localAccount.transfer(
-    { denom, value: amt.value },
-    {
-      value: destAddr,
-      encoding: 'bech32',
-      chainId,
-    },
-  );
   seat.exit();
+  void log(`transfer complete, seat exited`);
 };
 harden(sendIt);

package/src/examples/shared.flows.d.ts

@@ -0,0 +1,4 @@
+export function makeLocalAccount(orch: Orchestrator): Promise<LocalAccountMethods>;
+import type { Orchestrator } from '../types.js';
+import type { LocalAccountMethods } from '../types.js';
+//# sourceMappingURL=shared.flows.d.ts.map

package/src/examples/shared.flows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.flows.d.ts","sourceRoot":"","sources":["shared.flows.js"],"names":[],"mappings":"AAgBO,uCAHI,YAAY,GACV,OAAO,CAAC,mBAAmB,CAAC,CAKxC;kCAXsE,aAAa;yCAAb,aAAa"}

package/src/examples/shared.flows.js

@@ -0,0 +1,21 @@
+/**
+ * @file Flows shared by multiple examples
+ *
+ *   A module with flows can be used be reused across multiple contracts. They are
+ *   bound to a particular contract's context via orchestrateAll. See
+ *   ./send-anywhere.contract.js for example usage.
+ */
+/**
+ * @import {Orchestrator, OrchestrationFlow, LocalAccountMethods} from '../types.js';
+ */
+
+/**
+ * @satisfies {OrchestrationFlow}
+ * @param {Orchestrator} orch
+ * @returns {Promise<LocalAccountMethods>}
+ */
+export const makeLocalAccount = async orch => {
+  const agoricChain = await orch.getChain('agoric');
+  return agoricChain.makeAccount();
+};
+harden(makeLocalAccount);

package/src/examples/stake-bld.contract.d.ts

@@ -0,0 +1,49 @@
+export function start(zcf: ZCF, privateArgs: {
+    agoricNames: Remote<NameHub>;
+    localchain: Remote<LocalChain>;
+    marshaller: Marshaller;
+    storageNode: StorageNode;
+    timerService: TimerService;
+}, baggage: import("@agoric/vat-data").Baggage): Promise<{
+    publicFacet: import("@endo/exo").Guarded<{
+        /**
+         * Invitation to make an account, initialized with the give's BLD
+         */
+        makeStakeBldInvitation(): Promise<Invitation<import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("../utils/zoe-tools.js").ResolvedContinuingOfferResult>>, undefined>>;
+        makeAccount(): Promise<import("@endo/exo").Guarded<{
+            asContinuingOffer(): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("../utils/zoe-tools.js").ResolvedContinuingOfferResult>>;
+            getBalance(denom: import("../orchestration-api.js").DenomArg): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount>;
+            getBalances(): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount[]>;
+            getPublicTopics(): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<Record<string, import("@agoric/zoe/src/contractSupport/topics.js").ResolvedPublicTopic<unknown>>>>;
+            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">): import("@agoric/vow").Vow<void>;
+            withdraw(amount: import("@agoric/ertp").NatAmount): import("@agoric/vow").Vow<globalThis.Payment<"nat">>;
+            executeTx(messages: {
+                '@type': string;
+            }[]): import("@agoric/vow").Vow<{
+                '@type': string;
+            }[]>;
+            getAddress(): import("../orchestration-api.js").ChainAddress;
+            send(toAccount: import("../orchestration-api.js").ChainAddress, amounts: import("../orchestration-api.js").AmountArg): import("@agoric/vow").Vow<void>;
+            sendAll(toAccount: import("../orchestration-api.js").ChainAddress, amounts: import("../orchestration-api.js").AmountArg[]): import("@agoric/vow").Vow<void>;
+            transfer(destination: import("../orchestration-api.js").ChainAddress, amount: import("../orchestration-api.js").AmountArg, opts?: import("../cosmos-api.js").IBCMsgTransferOptions | undefined): import("@agoric/vow").Vow<any>;
+            transferSteps(amount: import("../orchestration-api.js").AmountArg, msg: import("../orchestration-api.js").TransferMsg): import("@agoric/vow").Vow<void>;
+            sendThenWaitForAck(packetSender: Remote<import("../exos/packet-tools.js").PacketSender>, opts?: import("../exos/packet-tools.js").PacketOptions | undefined): import("@agoric/async-flow").HostInterface<import("@agoric/vow").Vow<any>>;
+            matchFirstPacket(args_0?: import("@agoric/vow").EVow<globalThis.Pattern>): import("@agoric/async-flow").HostInterface<import("@agoric/vow").Vow<{
+                resolver: import("@agoric/vow").VowResolver<any>;
+                match: import("@agoric/vow").Vow<any>;
+            }>>;
+            monitorTransfers(tap: import("@agoric/vats/src/bridge-target.js").TargetApp): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("@agoric/vats/src/bridge-target.js").TargetRegistration>>;
+        }>>;
+        /**
+         * Invitation to make an account, without any funds
+         */
+        makeAccountInvitationMaker(): Promise<Invitation<import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("../utils/zoe-tools.js").ResolvedContinuingOfferResult>>, undefined>>;
+    }>;
+}>;
+import type { NameHub } from '@agoric/vats';
+import type { Remote } from '@agoric/internal';
+import type { LocalChain } from '@agoric/vats/src/localchain.js';
+import type { TimerService } from '@agoric/time';
+//# sourceMappingURL=stake-bld.contract.d.ts.map

package/src/examples/stake-bld.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stake-bld.contract.d.ts","sourceRoot":"","sources":["stake-bld.contract.js"],"names":[],"mappings":"AAoCO,2BAVI,GAAG,eACH;IACN,WAAW,EAAE,OAAO,OAAO,CAAC,CAAC;IAC7B,UAAU,EAAE,OAAO,UAAU,CAAC,CAAC;IAC/B,UAAU,EAAE,UAAU,CAAC;IACvB,WAAW,EAAE,WAAW,CAAC;IACzB,YAAY,EAAE,YAAY,CAAC;CAC5B,WACO,OAAO,kBAAkB,EAAE,OAAO;;QAsEvC;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA4BH;;WAEG;;;GAaR;6BApIyB,cAAc;4BACf,kBAAkB;gCAEd,gCAAgC;kCAD9B,cAAc"}

package/src/examples/{stakeBld.contract.js → stake-bld.contract.js}

@@ -12,6 +12,7 @@ import { M } from '@endo/patterns';
 import { makeChainHub } from '../exos/chain-hub.js';
 import { prepareLocalOrchestrationAccountKit } from '../exos/local-orchestration-account.js';
 import fetchedChainInfo from '../fetched-chain-info.js';
+import { makeZoeTools } from '../utils/zoe-tools.js';
 
 /**
  * @import {NameHub} from '@agoric/vats';
@@ -42,7 +43,12 @@ export const start = async (zcf, privateArgs, baggage) => {
   );
   const vowTools = prepareVowTools(zone.subZone('vows'));
 
-  const chainHub = makeChainHub(privateArgs.agoricNames, vowTools);
+  const chainHub = makeChainHub(
+    zone.subZone('chainHub'),
+    privateArgs.agoricNames,
+    vowTools,
+  );
+  const zoeTools = makeZoeTools(zcf, vowTools);
 
   const { localchain, timerService } = privateArgs;
   const makeLocalOrchestrationAccountKit = prepareLocalOrchestrationAccountKit(
@@ -54,6 +60,7 @@ export const start = async (zcf, privateArgs, baggage) => {
       vowTools,
       chainHub,
       localchain,
+      zoeTools,
     },
   );
 
@@ -104,6 +111,8 @@ export const start = async (zcf, privateArgs, baggage) => {
             const { give } = seat.getProposal();
             trace('makeStakeBldInvitation', give);
             const { holder } = await makeLocalAccountKit();
+            /** @type {Record<string, Payment<'nat'>>} */
+            // @ts-expect-error XXX PaymentPKeywordRecord throught deeplyFulfilled will be a PaymnentKeywordRecord
             const { In } = await deeplyFulfilled(
               withdrawFromSeat(zcf, seat, give),
             );

package/src/examples/stake-ica.contract.d.ts

@@ -0,0 +1,126 @@
+/**
+ * @import {Baggage} from '@agoric/vat-data';
+ * @import {Remote} from '@agoric/internal';
+ * @import {IBCConnectionID, NameHub} from '@agoric/vats';
+ * @import {TimerService} from '@agoric/time';
+ * @import {ResolvedContinuingOfferResult} from '../utils/zoe-tools.js';
+ * @import {ICQConnection, CosmosInterchainService, ChainHub} from '../types.js';
+ */
+/** @type {ContractMeta<typeof start>} */
+export const meta: ContractMeta<typeof start>;
+export const privateArgsShape: {
+    agoricNames: globalThis.Pattern;
+    cosmosInterchainService: globalThis.Pattern;
+    storageNode: globalThis.Pattern;
+    marshaller: globalThis.Pattern;
+    timer: globalThis.Pattern;
+} | undefined;
+export function start(zcf: ZCF<StakeIcaTerms>, privateArgs: {
+    agoricNames: Remote<NameHub>;
+    cosmosInterchainService: CosmosInterchainService;
+    storageNode: StorageNode;
+    marshaller: Marshaller;
+    timer: TimerService;
+}, baggage: Baggage): Promise<{
+    publicFacet: import("@endo/exo").Guarded<{
+        makeAccount(): Promise<import("@endo/exo").Guarded<{
+            asContinuingOffer(): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<ResolvedContinuingOfferResult>>;
+            getPublicTopics(): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<Record<string, import("@agoric/zoe/src/contractSupport/topics.js").ResolvedPublicTopic<unknown>>>>;
+            getAddress(): import("@agoric/async-flow").HostInterface<import("../orchestration-api.js").ChainAddress>;
+            delegate(validator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): import("@agoric/vow").Vow<void>;
+            redelegate(srcValidator: import("../cosmos-api.js").CosmosValidatorAddress, dstValidator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): import("@agoric/vow").Vow<void>;
+            withdrawReward(validator: import("../cosmos-api.js").CosmosValidatorAddress): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount[]>;
+            getBalance(denom: import("../orchestration-api.js").DenomArg): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount>;
+            getBalances(): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount[]>;
+            send(toAccount: import("../orchestration-api.js").ChainAddress, amounts: import("../orchestration-api.js").AmountArg): import("@agoric/vow").Vow<void>;
+            sendAll(toAccount: import("../orchestration-api.js").ChainAddress, amounts: import("../orchestration-api.js").AmountArg[]): import("@agoric/vow").Vow<void>;
+            transfer(destination: import("../orchestration-api.js").ChainAddress, amount: import("../orchestration-api.js").AmountArg, 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>;
+            withdrawRewards(): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount[]>;
+            undelegate(delegations: {
+                amount: import("../orchestration-api.js").AmountArg;
+                delegator?: import("../orchestration-api.js").ChainAddress;
+                validator: import("../cosmos-api.js").CosmosValidatorAddress;
+            }[]): import("@agoric/vow").Vow<void>;
+            deactivate(): import("@agoric/vow").Vow<void>;
+            reactivate(): import("@agoric/vow").Vow<void>;
+            getDelegation(validator: import("../cosmos-api.js").CosmosValidatorAddress): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("../cosmos-api.js").CosmosDelegationResponse>>;
+            getDelegations(): import("@agoric/vow").Vow<{
+                delegator: {
+                    chainId: string;
+                    value: string;
+                    encoding: "bech32" | "ethereum";
+                };
+                validator: {
+                    chainId: string;
+                    value: `${string}valoper${string}`;
+                    encoding: "bech32";
+                };
+                amount: {
+                    denom: import("../orchestration-api.js").Denom;
+                    value: bigint;
+                };
+            }[]>;
+            getUnbondingDelegation(validator: import("../cosmos-api.js").CosmosValidatorAddress): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").UnbondingDelegation>>;
+            getUnbondingDelegations(): import("@agoric/vow").Vow<{
+                delegatorAddress: string;
+                validatorAddress: string;
+                entries: {
+                    creationHeight: bigint;
+                    completionTime: {
+                        seconds: bigint;
+                        nanos: number;
+                    };
+                    initialBalance: string;
+                    balance: string;
+                }[];
+            }[]>;
+            getRedelegations(): import("@agoric/vow").Vow<{
+                redelegation: {
+                    delegatorAddress: string;
+                    validatorSrcAddress: string;
+                    validatorDstAddress: string;
+                    entries: {
+                        creationHeight: bigint;
+                        completionTime: {
+                            seconds: bigint;
+                            nanos: number;
+                        };
+                        initialBalance: string;
+                        sharesDst: string;
+                    }[];
+                };
+                entries: {
+                    redelegationEntry: {
+                        creationHeight: bigint;
+                        completionTime: {
+                            seconds: bigint;
+                            nanos: number;
+                        };
+                        initialBalance: string;
+                        sharesDst: string;
+                    };
+                    balance: string;
+                }[];
+            }[]>;
+            getReward(validator: import("../cosmos-api.js").CosmosValidatorAddress): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount[]>;
+            getRewards(): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("../cosmos-api.js").CosmosRewardsResponse>>;
+        }>>;
+        makeAccountInvitationMaker(): Promise<Invitation<ResolvedContinuingOfferResult, undefined>>;
+    }>;
+}>;
+export type StakeIcaTerms = {
+    chainId: string;
+    hostConnectionId: IBCConnectionID;
+    controllerConnectionId: IBCConnectionID;
+    icqEnabled: boolean;
+};
+export type StakeIcaSF = typeof start;
+import type { NameHub } from '@agoric/vats';
+import type { Remote } from '@agoric/internal';
+import type { CosmosInterchainService } from '../types.js';
+import type { TimerService } from '@agoric/time';
+import type { Baggage } from '@agoric/vat-data';
+import type { ResolvedContinuingOfferResult } from '../utils/zoe-tools.js';
+import type { IBCConnectionID } from '@agoric/vats';
+//# sourceMappingURL=stake-ica.contract.d.ts.map

package/src/examples/stake-ica.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stake-ica.contract.d.ts","sourceRoot":"","sources":["stake-ica.contract.js"],"names":[],"mappings":"AAgBA;;;;;;;GAOG;AAEH,yCAAyC;AACzC,mBADW,YAAY,CAAC,OAAO,KAAK,CAAC,CAelC;AAEH;;;;;;cAAsD;AAuB/C,2BAVI,GAAG,CAAC,aAAa,CAAC,eAClB;IACN,WAAW,EAAE,OAAO,OAAO,CAAC,CAAC;IAC7B,uBAAuB,EAAE,uBAAuB,CAAC;IACjD,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,UAAU,CAAC;IACvB,KAAK,EAAE,YAAY,CAAC;CACrB,WACO,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyGjB;4BA1HY;IACR,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,eAAe,CAAC;IAClC,sBAAsB,EAAE,eAAe,CAAC;IACxC,UAAU,EAAE,OAAO,CAAC;CACrB;yBAwHU,OAAO,KAAK;6BAxJiB,cAAc;4BADhC,kBAAkB;6CAIwB,aAAa;kCAFjD,cAAc;6BAHnB,kBAAkB;mDAII,uBAAuB;qCAF5B,cAAc"}

package/src/examples/{stakeIca.contract.js → stake-ica.contract.js}

@@ -6,7 +6,7 @@ import { heapVowE as E, prepareVowTools } from '@agoric/vow/vat.js';
 import {
   prepareRecorderKitMakers,
   provideAll,
-} from '@agoric/zoe/src/contractSupport';
+} from '@agoric/zoe/src/contractSupport/index.js';
 import { InvitationShape } from '@agoric/zoe/src/typeGuards.js';
 import { makeDurableZone } from '@agoric/zone/durable.js';
 import { M } from '@endo/patterns';
@@ -84,7 +84,11 @@ export const start = async (zcf, privateArgs, baggage) => {
 
   const vowTools = prepareVowTools(zone.subZone('vows'));
 
-  const chainHub = makeChainHub(agoricNames, vowTools);
+  const chainHub = makeChainHub(
+    zone.subZone('chainHub'),
+    agoricNames,
+    vowTools,
+  );
 
   const makeCosmosOrchestrationAccount = prepareCosmosOrchestrationAccount(
     zone,

package/src/examples/staking-combinations.contract.d.ts

@@ -2,7 +2,7 @@ export const start: (zcf: ZCF<Record<string, unknown>>, privateArgs: Orchestrati
     marshaller: Marshaller;
 }, baggage: import("@agoric/vat-data").Baggage) => Promise<{
     publicFacet: import("@endo/exo").Guarded<{
-        makeAccount(): Promise<Invitation<import("@agoric/vow").Vow<import("@agoric/smart-wallet/src/types.js").ContinuingOfferResult>, {
+        makeAccount(): Promise<Invitation<import("@agoric/vow").Vow<import("../utils/zoe-tools.js").ResolvedContinuingOfferResult>, {
             chainName: string;
         }>>;
     }>;

package/src/examples/staking-combinations.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"staking-combinations.contract.d.ts","sourceRoot":"","sources":["staking-combinations.contract.js"],"names":[],"mappings":"AA+JA;gBA1HiB,UAAU;;;;;;;;;;;;;;;;;;GA0HsB;yCA3IS,0BAA0B"}
+{"version":3,"file":"staking-combinations.contract.d.ts","sourceRoot":"","sources":["staking-combinations.contract.js"],"names":[],"mappings":"AAkKA;gBA7HiB,UAAU;;;;;;;;;;;;;;;;;;GA6HsB;yCA9IS,0BAA0B"}

package/src/examples/staking-combinations.contract.js

@@ -5,7 +5,6 @@
  *   The primary offer result is a power for invitation makers that can perform
  *   actions with an ICA account.
  */
-import { makeSharedStateRecord } from '@agoric/async-flow';
 import { AmountShape } from '@agoric/ertp';
 import { M } from '@endo/patterns';
 import { prepareCombineInvitationMakers } from '../exos/combine-invitation-makers.js';
@@ -13,6 +12,7 @@ import { CosmosOrchestrationInvitationMakersI } from '../exos/cosmos-orchestrati
 import { ChainAddressShape, DelegationShape } from '../typeGuards.js';
 import { withOrchestration } from '../utils/start-helper.js';
 import * as flows from './staking-combinations.flows.js';
+import * as sharedFlows from './shared.flows.js';
 import { prepareChainHubAdmin } from '../exos/chain-hub-admin.js';
 
 /**
@@ -46,16 +46,6 @@ const contract = async (
   zone,
   { orchestrateAll, zoeTools, chainHub },
 ) => {
-  const contractState = makeSharedStateRecord(
-    /**
-     * @type {{
-     *   account: (OrchestrationAccount<any> & LocalAccountMethods) | undefined;
-     * }}
-     */ {
-      localAccount: undefined,
-    },
-  );
-
   const StakingCombinationsInvitationMakersI = M.interface(
     'StakingCombinationsInvitationMakersI',
     {
@@ -128,12 +118,25 @@ const contract = async (
     StakingCombinationsInvitationMakersI,
   );
 
+  const { makeLocalAccount } = orchestrateAll(sharedFlows, {});
+  /**
+   * Setup a shared local account for use in async-flow functions. Typically,
+   * exo initState functions need to resolve synchronously, but `makeOnce`
+   * allows us to provide a Promise. When using this inside a flow, we must
+   * await it to ensure the account is available for use.
+   *
+   * @type {any} sharedLocalAccountP expects a Promise but this is a vow
+   *   https://github.com/Agoric/agoric-sdk/issues/9822
+   */
+  const sharedLocalAccountP = zone.makeOnce('localAccount', () =>
+    makeLocalAccount(),
+  );
+
   const orchFns = orchestrateAll(flows, {
-    contractState,
+    sharedLocalAccountP,
     makeCombineInvitationMakers,
     makeExtraInvitationMaker,
     flows,
-    zcf,
     zoeTools,
   });
 

package/src/examples/staking-combinations.flows.d.ts

@@ -3,11 +3,9 @@ export function makeAccount(orch: Orchestrator, ctx: {
     makeExtraInvitationMaker: (account: any) => InvitationMakers;
 }, _seat: ZCFSeat, { chainName }: {
     chainName: string;
-}): Promise<ContinuingOfferResult>;
-export function depositAndDelegate(orch: Orchestrator, { contractState, zoeTools }: {
-    contractState: {
-        localAccount?: OrchestrationAccountI & LocalAccountMethods;
-    };
+}): Promise<ResolvedContinuingOfferResult>;
+export function depositAndDelegate(orch: Orchestrator, { sharedLocalAccountP, zoeTools }: {
+    sharedLocalAccountP: Promise<GuestInterface<LocalOrchestrationAccountKit["holder"]>>;
     zoeTools: GuestInterface<ZoeTools>;
 }, account: GuestInterface<CosmosOrchestrationAccount>, seat: ZCFSeat, validator: CosmosValidatorAddress): Promise<void>;
 export function undelegateAndTransfer(orch: Orchestrator, ctx: object, account: GuestInterface<CosmosOrchestrationAccount>, { delegations, destination }: {
@@ -20,11 +18,10 @@ export function undelegateAndTransfer(orch: Orchestrator, ctx: object, account:
 import type { Orchestrator } from '../types.js';
 import type { MakeCombineInvitationMakers } from '../exos/combine-invitation-makers.js';
 import type { InvitationMakers } from '@agoric/smart-wallet/src/types.js';
-import type { ContinuingOfferResult } from '@agoric/smart-wallet/src/types.js';
-import type { OrchestrationAccountI } from '../types.js';
-import type { LocalAccountMethods } from '../types.js';
-import type { ZoeTools } from '../utils/zoe-tools.js';
+import type { ResolvedContinuingOfferResult } from '../utils/zoe-tools.js';
+import type { LocalOrchestrationAccountKit } from '../exos/local-orchestration-account.js';
 import type { GuestInterface } from '@agoric/async-flow';
+import type { ZoeTools } from '../utils/zoe-tools.js';
 import type { CosmosOrchestrationAccount } from '../exos/cosmos-orchestration-account.js';
 import type { CosmosValidatorAddress } from '../types.js';
 import type { AmountArg } from '../types.js';

package/src/examples/staking-combinations.flows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"staking-combinations.flows.d.ts","sourceRoot":"","sources":["staking-combinations.flows.js"],"names":[],"mappings":"AA2BO,kCATI,YAAY,OACZ;IACV,2BAA+B,EAAE,2BAA2B,CAAC;IAC7D,wBAA4B,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,gBAAgB,CAAC;CAC9D,SACO,OAAO,iBACP;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,GACnB,OAAO,CAAC,qBAAqB,CAAC,CAkB1C;AAcM,yCATI,YAAY,+BAEpB;IAA4E,aAAa,EAAjF;QAAE,YAAY,CAAC,EAAE,qBAAqB,GAAG,mBAAmB,CAAA;KAAE;IAChC,QAAQ,EAAtC,eAAe,QAAQ,CAAC;CAChC,WAAQ,eAAe,0BAA0B,CAAC,QAC1C,OAAO,aACP,sBAAsB,GACpB,OAAO,CAAC,IAAI,CAAC,CA6BzB;AAcM,4CATI,YAAY,OACZ,MAAM,WACN,eAAe,0BAA0B,CAAC,gCAC1C;IACV,WAAe,EAAE;QAAE,MAAM,EAAE,SAAS,CAAC;QAAC,SAAS,EAAE,sBAAsB,CAAA;KAAE,EAAE,CAAC;IAC5E,WAAe,EAAE,YAAY,CAAC;CAC3B,GACS,OAAO,CAAC,IAAI,CAAC,CAYzB;kCA1G8I,aAAa;iDAE9G,sCAAsC;sCAD1B,mCAAmC;2CAAnC,mCAAmC;2CADkD,aAAa;yCAAb,aAAa;8BAIjI,uBAAuB;oCALjB,oBAAoB;gDAIR,yCAAyC;4CAHyD,aAAa;+BAAb,aAAa;kCAAb,aAAa"}
+{"version":3,"file":"staking-combinations.flows.d.ts","sourceRoot":"","sources":["staking-combinations.flows.js"],"names":[],"mappings":"AA4BO,kCATI,YAAY,OACZ;IACN,2BAA2B,EAAE,2BAA2B,CAAC;IACzD,wBAAwB,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,gBAAgB,CAAC;CAC9D,SACO,OAAO,iBACP;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,GACnB,OAAO,CAAC,6BAA6B,CAAC,CAiBlD;AAcM,yCATI,YAAY,qCAEpB;IAA6E,mBAAmB,EAAxF,OAAO,CAAC,eAAe,4BAA4B,CAAC,QAAQ,CAAC,CAAC,CAAC;IACjC,QAAQ,EAAtC,eAAe,QAAQ,CAAC;CAChC,WAAQ,eAAe,0BAA0B,CAAC,QAC1C,OAAO,aACP,sBAAsB,GACpB,OAAO,CAAC,IAAI,CAAC,CAgCzB;AAcM,4CATI,YAAY,OACZ,MAAM,WACN,eAAe,0BAA0B,CAAC,gCAC1C;IACN,WAAW,EAAE;QAAE,MAAM,EAAE,SAAS,CAAC;QAAC,SAAS,EAAE,sBAAsB,CAAA;KAAE,EAAE,CAAC;IACxE,WAAW,EAAE,YAAY,CAAC;CAC3B,GACS,OAAO,CAAC,IAAI,CAAC,CAYzB;kCA7G8I,aAAa;iDAG9G,sCAAsC;sCAF1B,mCAAmC;mDAInC,uBAAuB;kDAHlC,wCAAwC;oCAHtD,oBAAoB;8BAMK,uBAAuB;gDADpC,yCAAyC;4CAJyD,aAAa;+BAAb,aAAa;kCAAb,aAAa"}

package/src/examples/staking-combinations.flows.js

@@ -2,13 +2,14 @@
  * @import {GuestInterface} from '@agoric/async-flow';
  * @import {Orchestrator, OrchestrationFlow, AmountArg, CosmosValidatorAddress, ChainAddress, LocalAccountMethods, OrchestrationAccountI} from '../types.js'
  * @import {ContinuingOfferResult, InvitationMakers} from '@agoric/smart-wallet/src/types.js';
+ * @import {LocalOrchestrationAccountKit} from '../exos/local-orchestration-account.js';
  * @import {MakeCombineInvitationMakers} from '../exos/combine-invitation-makers.js';
  * @import {CosmosOrchestrationAccount} from '../exos/cosmos-orchestration-account.js';
- * @import {ZoeTools} from '../utils/zoe-tools.js';
+ * @import {ResolvedContinuingOfferResult, ZoeTools} from '../utils/zoe-tools.js';
  */
 
 import { mustMatch } from '@endo/patterns';
-import { makeError } from '@endo/errors';
+import { makeError, q } from '@endo/errors';
 import { makeTracer } from '@agoric/internal';
 import { ChainAddressShape } from '../typeGuards.js';
 
@@ -23,7 +24,7 @@ const trace = makeTracer('StakingCombinationsFlows');
  * }} ctx
  * @param {ZCFSeat} _seat
  * @param {{ chainName: string }} offerArgs
- * @returns {Promise<ContinuingOfferResult>}
+ * @returns {Promise<ResolvedContinuingOfferResult>}
  */
 export const makeAccount = async (orch, ctx, _seat, { chainName }) => {
   const chain = await orch.getChain(chainName);
@@ -31,7 +32,6 @@ export const makeAccount = async (orch, ctx, _seat, { chainName }) => {
 
   const extraMakers = ctx.makeExtraInvitationMaker(account);
 
-  /** @type {ContinuingOfferResult} */
   const result = await account.asContinuingOffer();
 
   return {
@@ -48,7 +48,7 @@ harden(makeAccount);
  * @satisfies {OrchestrationFlow}
  * @param {Orchestrator} orch
  * @param {object} ctx
- * @param {{ localAccount?: OrchestrationAccountI & LocalAccountMethods }} ctx.contractState
+ * @param {Promise<GuestInterface<LocalOrchestrationAccountKit['holder']>>} ctx.sharedLocalAccountP
  * @param {GuestInterface<ZoeTools>} ctx.zoeTools
  * @param {GuestInterface<CosmosOrchestrationAccount>} account
  * @param {ZCFSeat} seat
@@ -57,7 +57,7 @@ harden(makeAccount);
  */
 export const depositAndDelegate = async (
   orch,
-  { contractState, zoeTools },
+  { sharedLocalAccountP, zoeTools },
   account,
   seat,
   validator,
@@ -65,20 +65,23 @@ export const depositAndDelegate = async (
   await null;
   trace('depositAndDelegate', account, seat, validator);
   mustMatch(validator, ChainAddressShape);
-  if (!contractState.localAccount) {
-    const agoricChain = await orch.getChain('agoric');
-    contractState.localAccount = await agoricChain.makeAccount();
-  }
+
   const { give } = seat.getProposal();
-  await zoeTools.localTransfer(seat, contractState.localAccount, give);
+  /**
+   * @type {any} XXX methods returning vows
+   *   https://github.com/Agoric/agoric-sdk/issues/9822
+   */
+  const sharedLocalAccount = await sharedLocalAccountP;
+  await zoeTools.localTransfer(seat, sharedLocalAccount, give);
 
   const address = account.getAddress();
   try {
-    await contractState.localAccount.transfer(give.Stake, address);
+    await sharedLocalAccount.transfer(address, give.Stake);
   } catch (cause) {
-    // TODO, put funds back on user seat and exit
-    // https://github.com/Agoric/agoric-sdk/issues/9925
-    throw makeError('ibc transfer failed', undefined, { cause });
+    await zoeTools.withdrawToSeat(sharedLocalAccount, seat, give);
+    const errMsg = makeError(`ibc transfer failed ${q(cause)}`);
+    seat.exit(errMsg);
+    throw errMsg;
   }
   seat.exit();
   await account.delegate(validator, give.Stake);
@@ -104,7 +107,7 @@ export const undelegateAndTransfer = async (
 ) => {
   await account.undelegate(delegations);
   for (const { amount } of delegations) {
-    await account.transfer(amount, destination);
+    await account.transfer(destination, amount);
   }
 };
 harden(undelegateAndTransfer);

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

@@ -1 +1 @@
-{"version":3,"file":"swap.contract.d.ts","sourceRoot":"","sources":["swap.contract.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AAEH,yCAAyC;AACzC,mBADW,YAAY,CAAC,OAAO,KAAK,CAAC,CAWnC;AASK,0CAHI,KAAK;;;EAIsC;AAiDtD;iBAzCkB,OAAO,OAAO,CAAC;gBAChB,OAAO,UAAU,CAAC;0BACR,OAAO,uBAAuB,CAAC;iBACxC,OAAO,WAAW,CAAC;kBAClB,OAAO,YAAY,CAAC;gBACtB,UAAU;;;;;;;;GAoCsB;6BA3EvB,cAAc;4BAFf,kBAAkB;gCADd,gCAAgC;6CAEnB,2BAA2B;kCAHtC,cAAc"}
+{"version":3,"file":"swap.contract.d.ts","sourceRoot":"","sources":["swap.contract.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AAEH,yCAAyC;AACzC,mBADW,YAAY,CAAC,OAAO,KAAK,CAAC,CAWnC;AASK,0CAHI,KAAK;;;EAIsC;AAgDtD;iBAxCkB,OAAO,OAAO,CAAC;gBAChB,OAAO,UAAU,CAAC;0BACR,OAAO,uBAAuB,CAAC;iBACxC,OAAO,WAAW,CAAC;kBAClB,OAAO,YAAY,CAAC;gBACtB,UAAU;;;;;;;;GAmCsB;6BA1EvB,cAAc;4BAFf,kBAAkB;gCADd,gCAAgC;6CAEnB,2BAA2B;kCAHtC,cAAc"}

package/src/examples/swap.contract.js

@@ -62,7 +62,6 @@ const contract = async (
   const { brands } = zcf.getTerms();
 
   const { stakeAndSwap } = orchestrateAll(flows, {
-    zcf,
     localTransfer: zoeTools.localTransfer,
   });
 

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

@@ -7,7 +7,7 @@ export const start: (zcf: ZCF<Record<string, unknown>>, privateArgs: {
     timerService: Remote<TimerService>;
 }, baggage: import("@agoric/vat-data").Baggage) => Promise<{
     publicFacet: import("@endo/exo").Guarded<{
-        makeUnbondAndLiquidStakeInvitation(): Promise<Invitation<import("@agoric/vow").Vow<void>, undefined>>;
+        makeUnbondAndTransferInvitation(): Promise<Invitation<import("@agoric/vow").Vow<void>, undefined>>;
     }>;
 }>;
 import type { NameHub } from '@agoric/vats';

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

@@ -1 +1 @@
-{"version":3,"file":"unbond.contract.d.ts","sourceRoot":"","sources":["unbond.contract.js"],"names":[],"mappings":"AAmDA;iBAhCkB,OAAO,OAAO,CAAC;gBAChB,OAAO,UAAU,CAAC;0BACR,OAAO,uBAAuB,CAAC;iBACxC,OAAO,WAAW,CAAC;gBACpB,UAAU;kBACR,OAAO,YAAY,CAAC;;;;;GA2BU;6BA5CvB,cAAc;4BACf,kBAAkB;gCAFd,gCAAgC;6CAInB,2BAA2B;kCALtC,cAAc"}
+{"version":3,"file":"unbond.contract.d.ts","sourceRoot":"","sources":["unbond.contract.js"],"names":[],"mappings":"AAwDA;iBArCkB,OAAO,OAAO,CAAC;gBAChB,OAAO,UAAU,CAAC;0BACR,OAAO,uBAAuB,CAAC;iBACxC,OAAO,WAAW,CAAC;gBACpB,UAAU;kBACR,OAAO,YAAY,CAAC;;;;;GAgCU;6BAjDvB,cAAc;4BACf,kBAAkB;gCAFd,gCAAgC;6CAInB,2BAA2B;kCALtC,cAAc"}

package/src/examples/unbond.contract.js

@@ -27,14 +27,19 @@ import * as flows from './unbond.flows.js';
  * @param {Zone} zone
  * @param {OrchestrationTools} tools
  */
-const contract = async (zcf, privateArgs, zone, { orchestrateAll }) => {
-  const { unbondAndLiquidStake } = orchestrateAll(flows, { zcf });
+const contract = async (
+  zcf,
+  privateArgs,
+  zone,
+  { orchestrateAll, zcfTools },
+) => {
+  const { unbondAndTransfer } = orchestrateAll(flows, { zcfTools });
 
   const publicFacet = zone.exo('publicFacet', undefined, {
-    makeUnbondAndLiquidStakeInvitation() {
+    makeUnbondAndTransferInvitation() {
       return zcf.makeInvitation(
-        unbondAndLiquidStake,
-        'Unbond and liquid stake',
+        unbondAndTransfer,
+        'Unbond and transfer',
         undefined,
         harden({
           // Nothing to give; the funds come from undelegating