@agoric/orchestration 0.1.1-dev-989aa19.0 → 0.1.1-dev-9274bc7.0

package/src/{utils/chainHub.d.ts.map → exos/chain-hub.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"chainHub.d.ts","sourceRoot":"","sources":["chainHub.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"chain-hub.d.ts","sourceRoot":"","sources":["chain-hub.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AAEH;;;;;GAKG;AAEH,wCAAwC;AACxC,gCAAiC;AACjC,kCAAkC;AAClC,gDAAiD;AAqB1C,wCAHI,MAAM,YACN,MAAM,UAUhB;AAqCM;IAaH;;;;;;;;;;;OAWG;wBAFQ,MAAM;;;;;;;;IAMjB;;;;OAIG;iBADkC,CAAC,4BAAD,CAAC,AAD1B,GACC,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;IAiBxC;;;;OAIG;iCAHQ,MAAM,YACN,MAAM;IAQjB;;;;OAIG;8BAHQ,MAAM,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,UAC5B,MAAM,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE;GAsB1C;AASM,gDALI,IAAI,CAAC,OAAO,cAAc,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,QACpD,MAAM;;;;;;;UAEN,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,KAAK,IAAI,iBAgCzC;AAYM,uCAHe,EAAE,iBAAmB,EAAE,2BAJlC,QAAQ,cAIG,EAAE,AAHX,cAG8B,EAAE,AAFhC,0EAiBZ;4BA1NuB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA+EvB,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wDA+EpD;;;;;mBAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAPW,UAAU,CAAC,OAAO,YAAY,CAAC;6BAtKnB,cAAc;4BAGf,kBAAkB;0BACpB,cAAc;uCAHgB,kBAAkB;+BAC9B,kBAAkB"}

package/src/{utils/chainHub.js → exos/chain-hub.js}

@@ -13,6 +13,13 @@ const { Fail } = assert;
  * @import {Zone} from '@agoric/zone';
  */
 
+/**
+ * @template {string} K
+ * @typedef {K extends keyof KnownChains
+ *   ? Omit<KnownChains[K], 'connections'>
+ *   : ChainInfo} ActualChainInfo
+ */
+
 /** agoricNames key for ChainInfo hub */
 export const CHAIN_KEY = 'chain';
 /** namehub for connection info */
@@ -47,7 +54,38 @@ export const connectionKey = (chainId1, chainId2) => {
   return [chainId1, chainId2].sort().join(CHAIN_ID_SEPARATOR);
 };
 
+const ChainIdArgShape = M.or(
+  M.string(),
+  M.splitRecord(
+    {
+      chainId: M.string(),
+    },
+    undefined,
+    M.any(),
+  ),
+);
+
+const ChainHubI = M.interface('ChainHub', {
+  registerChain: M.call(M.string(), CosmosChainInfoShape).returns(),
+  getChainInfo: M.callWhen(M.string()).returns(CosmosChainInfoShape),
+  registerConnection: M.callWhen(
+    M.string(),
+    M.string(),
+    IBCConnectionInfoShape,
+  ).returns(),
+  getConnectionInfo: M.callWhen(ChainIdArgShape, ChainIdArgShape).returns(
+    IBCConnectionInfoShape,
+  ),
+});
+
 /**
+ * Make a new ChainHub in the zone (or in the heap if no zone is provided).
+ *
+ * The resulting object is an Exo singleton. It has no precious state. It's only
+ * state is a cache of queries to agoricNames and whatever info was provided in
+ * registration calls. When you need a newer version you can simply make a hub
+ * hub and repeat the registrations.
+ *
  * @param {Remote<NameHub>} agoricNames
  * @param {Zone} [zone]
  */
@@ -63,7 +101,7 @@ export const makeChainHub = (agoricNames, zone = makeHeapZone()) => {
     valueShape: IBCConnectionInfoShape,
   });
 
-  const chainHub = harden({
+  const chainHub = zone.exo('ChainHub', ChainHubI, {
     /**
      * Register a new chain. The name will override a name in well known chain
      * names.
@@ -82,11 +120,7 @@ export const makeChainHub = (agoricNames, zone = makeHeapZone()) => {
     /**
      * @template {string} K
      * @param {K} chainName
-     * @returns {Promise<
-     *   K extends keyof KnownChains
-     *     ? Omit<KnownChains[K], 'connections'>
-     *     : ChainInfo
-     * >}
+     * @returns {Promise<ActualChainInfo<K>>}
      */
     async getChainInfo(chainName) {
       // Either from registerChain or memoized remote lookup()
@@ -114,11 +148,13 @@ export const makeChainHub = (agoricNames, zone = makeHeapZone()) => {
     },
 
     /**
-     * @param {string} chainId1
-     * @param {string} chainId2
+     * @param {string | { chainId: string }} chain1
+     * @param {string | { chainId: string }} chain2
      * @returns {Promise<IBCConnectionInfo>}
      */
-    async getConnectionInfo(chainId1, chainId2) {
+    async getConnectionInfo(chain1, chain2) {
+      const chainId1 = typeof chain1 === 'string' ? chain1 : chain1.chainId;
+      const chainId2 = typeof chain2 === 'string' ? chain2 : chain2.chainId;
       const key = connectionKey(chainId1, chainId2);
       if (connectionInfos.has(key)) {
         return connectionInfos.get(key);
@@ -175,3 +211,27 @@ export const registerChain = async (
   // Bundle to pipeline IO
   await Promise.all(promises);
 };
+
+/**
+ * @template {string} C1
+ * @template {string} C2
+ * @param {ChainHub} chainHub
+ * @param {C1} chainName1
+ * @param {C2} chainName2
+ * @returns {Promise<
+ *   [ActualChainInfo<C1>, ActualChainInfo<C2>, IBCConnectionInfo]
+ * >}
+ */
+export const getChainsAndConnection = async (
+  chainHub,
+  chainName1,
+  chainName2,
+) => {
+  const [chain1, chain2] = await Promise.all([
+    chainHub.getChainInfo(chainName1),
+    chainHub.getChainInfo(chainName2),
+  ]);
+  const connectionInfo = await chainHub.getConnectionInfo(chain2, chain1);
+
+  return [chain1, chain2, connectionInfo];
+};

package/src/exos/cosmos-orchestration-account.d.ts

@@ -29,14 +29,18 @@ export const IcaAccountHolderI: import("@endo/patterns").InterfaceGuard<{
     transferSteps: import("@endo/patterns").MethodGuard;
     deposit: import("@endo/patterns").MethodGuard;
 }>;
-export const trivialDelegateResponse: string;
-export function prepareCosmosOrchestrationAccountKit(zone: Zone, makeRecorderKit: <T>(storageNode: StorageNode | Awaited<import("@endo/far").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => RecorderKit<T>, zcf: ZCF): (chainAddress: ChainAddress, bondDenom: string, io: {
+export function prepareCosmosOrchestrationAccountKit(zone: Zone, makeRecorderKit: <T>(storageNode: StorageNode | Awaited<import("@endo/far").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => RecorderKit<T>, { when, watch }: {
+    when: <T_1, TResult1 = import("@agoric/vow").EUnwrap<T_1>, TResult2 = never>(specimenP: T_1, onFulfilled?: ((value: import("@agoric/vow").EUnwrap<T_1>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
+    watch: <T_2 = any, TResult1_1 = T_2, TResult2_1 = never, C = any>(specimenP: import("@agoric/vow").ERef<T_2 | import("@agoric/vow").Vow<T_2>>, watcher?: import("@agoric/vow").Watcher<T_2, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => import("@agoric/vow").Vow<Exclude<TResult1_1, void> | Exclude<TResult2_1, void> extends never ? TResult1_1 : Exclude<TResult1_1, void> | Exclude<TResult2_1, void>>;
+    makeVowKit: <T_3>() => import("@agoric/vow").VowKit<T_3>;
+    allVows: (vows: unknown[]) => import("@agoric/vow").Vow<any[]>;
+}, zcf: ZCF): (chainAddress: ChainAddress, bondDenom: string, io: {
     account: IcaAccount;
     storageNode: Remote<globalThis.StorageNode>;
     icqConnection: import("@endo/exo").Guarded<{
         getLocalAddress(): `/ibc-port/${string}`;
         getRemoteAddress(): `/${string}ibc-port/${string}/ordered/${string}` | `/${string}ibc-port/${string}/unordered/${string}`;
-        query(msgs: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").RequestQuery>[]): Promise<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").ResponseQuery>[]>;
+        query(msgs: JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").RequestQuery>[]): Promise<JsonSafe<ResponseQuery>[]>;
     }> | undefined;
     timer: Remote<TimerService>;
 }) => import("@endo/exo").GuardedKit<{
@@ -50,22 +54,46 @@ export function prepareCosmosOrchestrationAccountKit(zone: Zone, makeRecorderKit
          */
         amountToCoin(amount: AmountArg): Coin;
     };
+    balanceQueryWatcher: {
+        /**
+         * @param {JsonSafe<ResponseQuery>[]} results
+         */
+        onFulfilled([result]: JsonSafe<ResponseQuery>[]): DenomAmount;
+    };
+    undelegateWatcher: {
+        /**
+         * @param {string} result
+         */
+        onFulfilled(result: string): Promise<import("@agoric/time").TimestampRecord>;
+    };
+    /**
+     * takes an array of results (from `executeEncodedTx`) and returns void
+     * since we are not interested in the result
+     */
+    returnVoidWatcher: {
+        /** @param {string | Record<string, unknown>} result */
+        onFulfilled(result: string | Record<string, unknown>): undefined;
+    };
+    withdrawRewardWatcher: {
+        /** @param {string} result */
+        onFulfilled(result: string): DenomAmount[];
+    };
     invitationMakers: {
         /**
          * @param {CosmosValidatorAddress} validator
          * @param {AmountArg} amount
          */
-        Delegate(validator: CosmosValidatorAddress, amount: AmountArg): Promise<Invitation<void, undefined>>;
+        Delegate(validator: CosmosValidatorAddress, amount: AmountArg): Promise<Invitation<undefined, undefined>>;
         /**
          * @param {CosmosValidatorAddress} srcValidator
          * @param {CosmosValidatorAddress} dstValidator
          * @param {AmountArg} amount
          */
-        Redelegate(srcValidator: CosmosValidatorAddress, dstValidator: CosmosValidatorAddress, amount: AmountArg): Promise<Invitation<void, undefined>>;
+        Redelegate(srcValidator: CosmosValidatorAddress, dstValidator: CosmosValidatorAddress, amount: AmountArg): Promise<Invitation<undefined, undefined>>;
         /** @param {CosmosValidatorAddress} validator */
         WithdrawReward(validator: CosmosValidatorAddress): Promise<Invitation<DenomAmount[], undefined>>;
         /** @param {Omit<Delegation, 'delegatorAddress'>[]} delegations */
-        Undelegate(delegations: Omit<Delegation, "delegatorAddress">[]): Promise<Invitation<void, undefined>>;
+        Undelegate(delegations: Omit<Delegation, "delegatorAddress">[]): Promise<Invitation<undefined, undefined>>;
         CloseAccount(): never;
         /**
          * Starting a transfer revokes the account holder. The associated
@@ -88,17 +116,17 @@ export function prepareCosmosOrchestrationAccountKit(zone: Zone, makeRecorderKit
                  * @param {CosmosValidatorAddress} validator
                  * @param {AmountArg} amount
                  */
-                Delegate(validator: CosmosValidatorAddress, amount: AmountArg): Promise<Invitation<void, undefined>>;
+                Delegate(validator: CosmosValidatorAddress, amount: AmountArg): Promise<Invitation<undefined, undefined>>;
                 /**
                  * @param {CosmosValidatorAddress} srcValidator
                  * @param {CosmosValidatorAddress} dstValidator
                  * @param {AmountArg} amount
                  */
-                Redelegate(srcValidator: CosmosValidatorAddress, dstValidator: CosmosValidatorAddress, amount: AmountArg): Promise<Invitation<void, undefined>>;
+                Redelegate(srcValidator: CosmosValidatorAddress, dstValidator: CosmosValidatorAddress, amount: AmountArg): Promise<Invitation<undefined, undefined>>;
                 /** @param {CosmosValidatorAddress} validator */
                 WithdrawReward(validator: CosmosValidatorAddress): Promise<Invitation<DenomAmount[], undefined>>;
                 /** @param {Omit<Delegation, 'delegatorAddress'>[]} delegations */
-                Undelegate(delegations: Omit<Delegation, "delegatorAddress">[]): Promise<Invitation<void, undefined>>;
+                Undelegate(delegations: Omit<Delegation, "delegatorAddress">[]): Promise<Invitation<undefined, undefined>>;
                 CloseAccount(): never;
                 /**
                  * Starting a transfer revokes the account holder. The associated
@@ -124,7 +152,7 @@ export function prepareCosmosOrchestrationAccountKit(zone: Zone, makeRecorderKit
          * @param {CosmosValidatorAddress} validator
          * @param {AmountArg} amount
          */
-        delegate(validator: CosmosValidatorAddress, amount: AmountArg): Promise<void>;
+        delegate(validator: CosmosValidatorAddress, amount: AmountArg): Promise<undefined>;
         deposit(payment: any): Promise<void>;
         getBalances(): Promise<never>;
         /**
@@ -134,7 +162,7 @@ export function prepareCosmosOrchestrationAccountKit(zone: Zone, makeRecorderKit
          * @param {CosmosValidatorAddress} dstValidator
          * @param {AmountArg} amount
          */
-        redelegate(srcValidator: CosmosValidatorAddress, dstValidator: CosmosValidatorAddress, amount: AmountArg): Promise<void>;
+        redelegate(srcValidator: CosmosValidatorAddress, dstValidator: CosmosValidatorAddress, amount: AmountArg): Promise<undefined>;
         /**
          * @param {CosmosValidatorAddress} validator
          * @returns {Promise<DenomAmount[]>}
@@ -150,10 +178,15 @@ export function prepareCosmosOrchestrationAccountKit(zone: Zone, makeRecorderKit
         transferSteps(amount: any, msg: any): never;
         withdrawRewards(): never;
         /** @param {Omit<Delegation, 'delegatorAddress'>[]} delegations */
-        undelegate(delegations: Omit<Delegation, "delegatorAddress">[]): Promise<void>;
+        undelegate(delegations: Omit<Delegation, "delegatorAddress">[]): Promise<undefined>;
     };
 }>;
-export function prepareCosmosOrchestrationAccount(zone: Zone, makeRecorderKit: <T>(storageNode: StorageNode | Awaited<import("@endo/far").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => RecorderKit<T>, zcf: ZCF): (...args: Parameters<ReturnType<typeof prepareCosmosOrchestrationAccountKit>>) => CosmosOrchestrationAccountKit["holder"];
+export function prepareCosmosOrchestrationAccount(zone: Zone, makeRecorderKit: <T>(storageNode: StorageNode | Awaited<import("@endo/far").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => RecorderKit<T>, vowTools: {
+    when: <T_1, TResult1 = import("@agoric/vow").EUnwrap<T_1>, TResult2 = never>(specimenP: T_1, onFulfilled?: ((value: import("@agoric/vow").EUnwrap<T_1>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
+    watch: <T_2 = any, TResult1_1 = T_2, TResult2_1 = never, C = any>(specimenP: import("@agoric/vow").ERef<T_2 | import("@agoric/vow").Vow<T_2>>, watcher?: import("@agoric/vow").Watcher<T_2, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => import("@agoric/vow").Vow<Exclude<TResult1_1, void> | Exclude<TResult2_1, void> extends never ? TResult1_1 : Exclude<TResult1_1, void> | Exclude<TResult2_1, void>>;
+    makeVowKit: <T_3>() => import("@agoric/vow").VowKit<T_3>;
+    allVows: (vows: unknown[]) => import("@agoric/vow").Vow<any[]>;
+}, zcf: ZCF): (...args: Parameters<ReturnType<typeof prepareCosmosOrchestrationAccountKit>>) => CosmosOrchestrationAccountKit["holder"];
 export type ComosOrchestrationAccountNotification = {
     chainAddress: ChainAddress;
 };
@@ -164,7 +197,7 @@ export type State = {
     icqConnection: import("@endo/exo").Guarded<{
         getLocalAddress(): `/ibc-port/${string}`;
         getRemoteAddress(): `/${string}ibc-port/${string}/ordered/${string}` | `/${string}ibc-port/${string}/unordered/${string}`;
-        query(msgs: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").RequestQuery>[]): Promise<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").ResponseQuery>[]>;
+        query(msgs: JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").RequestQuery>[]): Promise<JsonSafe<ResponseQuery>[]>;
     }> | undefined;
     bondDenom: string;
     timer: Remote<TimerService>;
@@ -176,11 +209,13 @@ import type { RecorderKit } from '@agoric/zoe/src/contractSupport/recorder.js';
 import type { ChainAddress } from '../types.js';
 import type { IcaAccount } from '../types.js';
 import type { Remote } from '@agoric/internal';
+import type { JsonSafe } from '@agoric/cosmic-proto';
+import type { ResponseQuery } from '@agoric/cosmic-proto/tendermint/abci/types.js';
 import type { TimerService } from '@agoric/time';
 import type { AmountArg } from '../types.js';
 import type { Coin } from '@agoric/cosmic-proto/cosmos/base/v1beta1/coin.js';
-import type { CosmosValidatorAddress } from '../types.js';
 import type { DenomAmount } from '../types.js';
+import type { CosmosValidatorAddress } from '../types.js';
 import type { Delegation } from '@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js';
 import type { DenomArg } from '../types.js';
 //# sourceMappingURL=cosmos-orchestration-account.d.ts.map

package/src/exos/cosmos-orchestration-account.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cosmos-orchestration-account.d.ts","sourceRoot":"","sources":["cosmos-orchestration-account.js"],"names":[],"mappings":"AAmDA;;;GAGG;AAEH;;;;;;;;;GASG;AAEH,mCAAmC;AACnC;;;;;;;;;;;;;;;GAqBG;AAOH,6CAGE;AAgBK,mGAgCsB,WAAW,GACnC,QAAI,OAAO,WAAW,EAAE,MAAM,CAAC,WACnC,CAAC,CAAC,0HApCQ,GAAG;;;;;;;;;;;QAuDN,wDAAwD;;;QAWxD;;;WAGG;;;;QAgBH;;;WAGG;;QASH;;;;WAIG;;QAaH,gDAAgD;;QAShD,kEAAkE;;;QAYlE;;;;WAIG;;;;;;;;;;;;;gBAtDH;;;mBAGG;;gBASH;;;;mBAIG;;gBAaH,gDAAgD;;gBAShD,kEAAkE;;;gBAYlE;;;;mBAIG;;;;;;;;;;;;QA2BH,8BAA8B;;QAI9B;;;;;WAKG;;;;QA2BH;;;;;;WAMG;;QAmBH;;;WAGG;;QAmBH;;;WAGG;;;;;;QA4CH,kEAAkE;;;GAgCzE;AAkBM,0IAvTsB,MAAM,wIAgTxB,GAAG,GACD,CACZ,GAAO,IAAI,EAAE,UAAU,CACvB,UAAgB,CAAC,OAAO,oCAAoC,CAAC,CACxD,KACE,6BAA6B,CAAC,QAAQ,CAAC,CAa9C;;;;;;;;;;;;;eAxZe,MAAM;;;4CA8XT,UAAU,CACtB,UAAc,CAAC,OAAO,oCAAoC,CAAC,CACxD;yCAyBU,6BAA6B,CAAC,QAAQ,CAAC;0BA1a9B,cAAc;iCALU,6CAA6C;kCADsE,aAAa;gCAAb,aAAa;4BAItJ,kBAAkB;kCACZ,cAAc;+BALqH,aAAa;0BAExJ,kDAAkD;4CAFyF,aAAa;iCAAb,aAAa;gCAGlJ,wDAAwD;8BAH6E,aAAa"}
+{"version":3,"file":"cosmos-orchestration-account.d.ts","sourceRoot":"","sources":["cosmos-orchestration-account.js"],"names":[],"mappings":"AAkDA;;;GAGG;AAEH;;;;;;;;;GASG;AAEH,mCAAmC;AACnC;;;;;;;;;;;;;;;GAqBG;AAgBI,mGA+BG,WAAE,GAAE,QAAS,OAAO,WAAW,EAAE,MAAM,CAAC,WAAW,CAAC,CAC9D;4FAzHA,GAAC;;;oBAO0B,SACtB;QA+EM,GAAG;;;;;;;;;;;QA4EN,wDAAwD;;;QAWxD;;;WAGG;;;;QAgBH;;WAEG;;;;QAWH;;WAEG;4BADQ,MAAM;;IAenB;;;OAGG;;QAED,uDAAuD;4BAA3C,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;QAO5C,6BAA6B;4BAAjB,MAAM;;;QAYlB;;;WAGG;;QASH;;;;WAIG;;QAaH,gDAAgD;;QAShD,kEAAkE;;;QAYlE;;;;WAIG;;;;;;;;;;;;;gBAtDH;;;mBAGG;;gBASH;;;;mBAIG;;gBAaH,gDAAgD;;gBAShD,kEAAkE;;;gBAYlE;;;;mBAIG;;;;;;;;;;;;QA2BH,8BAA8B;;QAI9B;;;;;WAKG;;;;QA0BH;;;;;;WAMG;;QAyBH;;;WAGG;;QAcH;;;WAGG;;;;;;QAuCH,kEAAkE;;;GA2BzE;AAmBM,0IA1XoC,MAAM;;;;;QAmXtC,GAAG,GACD,CACZ,GAAO,IAAI,EAAE,UAAU,CACvB,UAAgB,CAAC,OAAO,oCAAoC,CAAC,CACxD,KACE,6BAA6B,CAAC,QAAQ,CAAC,CAe9C;;;;;;;;;;;;;eAjde,MAAM;;;4CAobT,UAAU,CACtB,UAAc,CAAC,OAAO,oCAAoC,CAAC,CACxD;yCA4BU,6BAA6B,CAAC,QAAQ,CAAC;0BAre9B,cAAc;iCANU,6CAA6C;kCADsE,aAAa;gCAAb,aAAa;4BAItJ,kBAAkB;8BAKhB,sBAAsB;mCADjB,+CAA+C;kCAHhD,cAAc;+BALqH,aAAa;0BAExJ,kDAAkD;iCAFyF,aAAa;4CAAb,aAAa;gCAGlJ,wDAAwD;8BAH6E,aAAa"}

package/src/exos/cosmos-orchestration-account.js

@@ -11,7 +11,6 @@ import {
 import {
   MsgBeginRedelegate,
   MsgDelegate,
-  MsgDelegateResponse,
   MsgUndelegate,
   MsgUndelegateResponse,
 } from '@agoric/cosmic-proto/cosmos/staking/v1beta1/tx.js';
@@ -26,13 +25,10 @@ import {
   AmountArgShape,
   ChainAddressShape,
   ChainAmountShape,
+  CoinShape,
   DelegationShape,
 } from '../typeGuards.js';
-import {
-  encodeTxResponse,
-  maxClockSkew,
-  tryDecodeResponse,
-} from '../utils/cosmos.js';
+import { maxClockSkew, tryDecodeResponse } from '../utils/cosmos.js';
 import { orchestrationAccountMethods } from '../utils/orchestrationAccount.js';
 import { dateInSeconds } from '../utils/time.js';
 
@@ -43,7 +39,10 @@ import { dateInSeconds } from '../utils/time.js';
  * @import {Delegation} from '@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js';
  * @import {Remote} from '@agoric/internal';
  * @import {TimerService} from '@agoric/time';
+ * @import {VowTools} from '@agoric/vow';
  * @import {Zone} from '@agoric/zone';
+ * @import {ResponseQuery} from '@agoric/cosmic-proto/tendermint/abci/types.js';
+ * @import {JsonSafe} from '@agoric/cosmic-proto';
  */
 
 const trace = makeTracer('ComosOrchestrationAccountHolder');
@@ -94,28 +93,19 @@ const PUBLIC_TOPICS = {
   account: ['Staking Account holder status', M.any()],
 };
 
-export const trivialDelegateResponse = encodeTxResponse(
-  {},
-  MsgDelegateResponse.toProtoMsg,
-);
-
-const expect = (actual, expected, message) => {
-  if (actual !== expected) {
-    console.log(message, { actual, expected });
-  }
-};
-
 /** @type {(c: { denom: string; amount: string }) => DenomAmount} */
 const toDenomAmount = c => ({ denom: c.denom, value: BigInt(c.amount) });
 
 /**
  * @param {Zone} zone
  * @param {MakeRecorderKit} makeRecorderKit
+ * @param {VowTools} vowTools
  * @param {ZCF} zcf
  */
 export const prepareCosmosOrchestrationAccountKit = (
   zone,
   makeRecorderKit,
+  { when, watch },
   zcf,
 ) => {
   const makeCosmosOrchestrationAccountKit = zone.exoClassKit(
@@ -126,6 +116,26 @@ export const prepareCosmosOrchestrationAccountKit = (
         getUpdater: M.call().returns(M.remotable()),
         amountToCoin: M.call(AmountArgShape).returns(M.record()),
       }),
+      returnVoidWatcher: M.interface('returnVoidWatcher', {
+        onFulfilled: M.call(M.or(M.string(), M.record()))
+          .optional(M.arrayOf(M.undefined()))
+          .returns(M.undefined()),
+      }),
+      balanceQueryWatcher: M.interface('balanceQueryWatcher', {
+        onFulfilled: M.call(M.arrayOf(M.record()))
+          .optional(M.arrayOf(M.undefined())) // empty context
+          .returns(M.or(M.record(), M.undefined())),
+      }),
+      undelegateWatcher: M.interface('undelegateWatcher', {
+        onFulfilled: M.call(M.string())
+          .optional(M.arrayOf(M.undefined())) // empty context
+          .returns(M.promise()),
+      }),
+      withdrawRewardWatcher: M.interface('withdrawRewardWatcher', {
+        onFulfilled: M.call(M.string())
+          .optional(M.arrayOf(M.undefined())) // empty context
+          .returns(M.arrayOf(CoinShape)),
+      }),
       holder: IcaAccountHolderI,
       invitationMakers: M.interface('invitationMakers', {
         Delegate: M.callWhen(ChainAddressShape, AmountArgShape).returns(
@@ -195,6 +205,59 @@ export const prepareCosmosOrchestrationAccountKit = (
           });
         },
       },
+      balanceQueryWatcher: {
+        /**
+         * @param {JsonSafe<ResponseQuery>[]} results
+         */
+        onFulfilled([result]) {
+          if (!result?.key) throw Fail`Error parsing result ${result}`;
+          const { balance } = QueryBalanceResponse.decode(
+            decodeBase64(result.key),
+          );
+          if (!balance) throw Fail`Result lacked balance key: ${result}`;
+          return harden(toDenomAmount(balance));
+        },
+      },
+      undelegateWatcher: {
+        /**
+         * @param {string} result
+         */
+        onFulfilled(result) {
+          const response = tryDecodeResponse(
+            result,
+            MsgUndelegateResponse.fromProtoMsg,
+          );
+          trace('undelegate response', response);
+          const { completionTime } = response;
+          completionTime || Fail`No completion time result ${result}`;
+          return E(this.state.timer).wakeAt(
+            dateInSeconds(completionTime) + maxClockSkew,
+          );
+        },
+      },
+      /**
+       * takes an array of results (from `executeEncodedTx`) and returns void
+       * since we are not interested in the result
+       */
+      returnVoidWatcher: {
+        /** @param {string | Record<string, unknown>} result */
+        onFulfilled(result) {
+          trace('Result', result);
+          return undefined;
+        },
+      },
+      withdrawRewardWatcher: {
+        /** @param {string} result */
+        onFulfilled(result) {
+          const response = tryDecodeResponse(
+            result,
+            MsgWithdrawDelegatorRewardResponse.fromProtoMsg,
+          );
+          trace('withdrawReward response', response);
+          const { amount: coins } = response;
+          return harden(coins.map(toDenomAmount));
+        },
+      },
       invitationMakers: {
         /**
          * @param {CosmosValidatorAddress} validator
@@ -292,7 +355,7 @@ export const prepareCosmosOrchestrationAccountKit = (
           const { helper } = this.facets;
           const { chainAddress } = this.state;
 
-          const result = await E(helper.owned()).executeEncodedTx([
+          const results = E(helper.owned()).executeEncodedTx([
             Any.toJSON(
               MsgDelegate.toProtoMsg({
                 delegatorAddress: chainAddress.address,
@@ -301,8 +364,7 @@ export const prepareCosmosOrchestrationAccountKit = (
               }),
             ),
           ]);
-
-          expect(result, trivialDelegateResponse, 'MsgDelegateResponse');
+          return when(watch(results, this.facets.returnVoidWatcher));
         },
         async deposit(payment) {
           trace('deposit', payment);
@@ -325,8 +387,7 @@ export const prepareCosmosOrchestrationAccountKit = (
           const { helper } = this.facets;
           const { chainAddress } = this.state;
 
-          // NOTE: response, including completionTime, is currently discarded.
-          await E(helper.owned()).executeEncodedTx([
+          const results = E(helper.owned()).executeEncodedTx([
             Any.toJSON(
               MsgBeginRedelegate.toProtoMsg({
                 delegatorAddress: chainAddress.address,
@@ -336,8 +397,15 @@ export const prepareCosmosOrchestrationAccountKit = (
               }),
             ),
           ]);
-        },
 
+          return when(
+            watch(
+              results,
+              // NOTE: response, including completionTime, is currently discarded.
+              this.facets.returnVoidWatcher,
+            ),
+          );
+        },
         /**
          * @param {CosmosValidatorAddress} validator
          * @returns {Promise<DenomAmount[]>}
@@ -351,14 +419,9 @@ export const prepareCosmosOrchestrationAccountKit = (
             validatorAddress: validator.address,
           });
           const account = helper.owned();
-          const result = await E(account).executeEncodedTx([Any.toJSON(msg)]);
-          const response = tryDecodeResponse(
-            result,
-            MsgWithdrawDelegatorRewardResponse.fromProtoMsg,
-          );
-          trace('withdrawReward response', response);
-          const { amount: coins } = response;
-          return harden(coins.map(toDenomAmount));
+
+          const results = E(account).executeEncodedTx([Any.toJSON(msg)]);
+          return when(watch(results, this.facets.withdrawRewardWatcher));
         },
         /**
          * @param {DenomArg} denom
@@ -372,7 +435,7 @@ export const prepareCosmosOrchestrationAccountKit = (
           // TODO #9211 lookup denom from brand
           assert.typeof(denom, 'string');
 
-          const [result] = await E(icqConnection).query([
+          const results = E(icqConnection).query([
             toRequestQueryJson(
               QueryBalanceRequest.toProtoMsg({
                 address: chainAddress.address,
@@ -380,12 +443,7 @@ export const prepareCosmosOrchestrationAccountKit = (
               }),
             ),
           ]);
-          if (!result?.key) throw Fail`Error parsing result ${result}`;
-          const { balance } = QueryBalanceResponse.decode(
-            decodeBase64(result.key),
-          );
-          if (!balance) throw Fail`Result lacked balance key: ${result}`;
-          return harden(toDenomAmount(balance));
+          return when(watch(results, this.facets.balanceQueryWatcher));
         },
 
         send(toAccount, amount) {
@@ -411,28 +469,23 @@ export const prepareCosmosOrchestrationAccountKit = (
         async undelegate(delegations) {
           trace('undelegate', delegations);
           const { helper } = this.facets;
-          const { chainAddress, bondDenom, timer } = this.state;
-
-          const result = await E(helper.owned()).executeEncodedTx(
-            delegations.map(d =>
-              Any.toJSON(
-                MsgUndelegate.toProtoMsg({
-                  delegatorAddress: chainAddress.address,
-                  validatorAddress: d.validatorAddress,
-                  amount: { denom: bondDenom, amount: d.shares },
-                }),
+          const { chainAddress, bondDenom } = this.state;
+
+          const undelegateV = watch(
+            E(helper.owned()).executeEncodedTx(
+              delegations.map(d =>
+                Any.toJSON(
+                  MsgUndelegate.toProtoMsg({
+                    delegatorAddress: chainAddress.address,
+                    validatorAddress: d.validatorAddress,
+                    amount: { denom: bondDenom, amount: d.shares },
+                  }),
+                ),
               ),
             ),
+            this.facets.undelegateWatcher,
           );
-
-          const response = tryDecodeResponse(
-            result,
-            MsgUndelegateResponse.fromProtoMsg,
-          );
-          trace('undelegate response', response);
-          const { completionTime } = response;
-
-          await E(timer).wakeAt(dateInSeconds(completionTime) + maxClockSkew);
+          return when(watch(undelegateV, this.facets.returnVoidWatcher));
         },
       },
     },
@@ -450,6 +503,7 @@ export const prepareCosmosOrchestrationAccountKit = (
 /**
  * @param {Zone} zone
  * @param {MakeRecorderKit} makeRecorderKit
+ * @param {VowTools} vowTools
  * @param {ZCF} zcf
  * @returns {(
  *   ...args: Parameters<
@@ -460,11 +514,13 @@ export const prepareCosmosOrchestrationAccountKit = (
 export const prepareCosmosOrchestrationAccount = (
   zone,
   makeRecorderKit,
+  vowTools,
   zcf,
 ) => {
   const makeKit = prepareCosmosOrchestrationAccountKit(
     zone,
     makeRecorderKit,
+    vowTools,
     zcf,
   );
   return (...args) => makeKit(...args).holder;

package/src/exos/icq-connection-kit.d.ts

@@ -4,7 +4,12 @@ export const ICQConnectionI: import("@endo/patterns").InterfaceGuard<{
     getRemoteAddress: import("@endo/patterns").MethodGuard;
     query: import("@endo/patterns").MethodGuard;
 }>;
-export function prepareICQConnectionKit(zone: Zone): (port: Port) => import("@endo/exo").GuardedKit<{
+export function prepareICQConnectionKit(zone: Zone, { watch, when }: {
+    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_1 = any, TResult1_1 = T_1, TResult2_1 = never, C = any>(specimenP: import("@agoric/vow").ERef<T_1 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => import("@agoric/vow").Vow<Exclude<TResult1_1, void> | Exclude<TResult2_1, void> extends never ? TResult1_1 : Exclude<TResult1_1, void> | Exclude<TResult2_1, void>>;
+    makeVowKit: <T_2>() => import("@agoric/vow").VowKit<T_2>;
+    allVows: (vows: unknown[]) => import("@agoric/vow").Vow<any[]>;
+}): (port: Port) => import("@endo/exo").GuardedKit<{
     connection: {
         getLocalAddress(): `/ibc-port/${string}`;
         getRemoteAddress(): `/${string}ibc-port/${string}/ordered/${string}` | `/${string}ibc-port/${string}/unordered/${string}`;
@@ -15,6 +20,10 @@ export function prepareICQConnectionKit(zone: Zone): (port: Port) => import("@en
          */
         query(msgs: JsonSafe<RequestQuery>[]): Promise<JsonSafe<ResponseQuery>[]>;
     };
+    parseQueryPacketWatcher: {
+        /** @param {string} ack packet acknowledgement string */
+        onFulfilled(ack: string): JsonSafe<ResponseQuery>[];
+    };
     connectionHandler: {
         /**
          * @param {Remote<Connection>} connection

package/src/exos/icq-connection-kit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"icq-connection-kit.d.ts","sourceRoot":"","sources":["icq-connection-kit.js"],"names":[],"mappings":"AAoBA,2DAGE;AAEF;;;;GAIG;AA0BI;;;;QA4BC;;;;WAIG;;;;QAYH;;;;WAIG;;;;;GAgBR;;;;;;;+BAEW,UAAU,CAAC,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;4BACtD,gBAAgB,CAAC,YAAY,CAAC;0BAjHrB,mBAAmB;0BACP,iBAAiB;kCAGN,+CAA+C;8BADlE,sBAAsB;mCACH,+CAA+C;gCAH1D,iBAAiB;4BAC3B,aAAa"}
+{"version":3,"file":"icq-connection-kit.d.ts","sourceRoot":"","sources":["icq-connection-kit.js"],"names":[],"mappings":"AAoBA,2DAGE;AAEF;;;;GAIG;AA2BI;wFA7CqC,CAAC;;;oBAW7B,SAAS;;;;;QAoEjB;;;;WAIG;;;;QAeH,wDAAwD;yBAA5C,MAAM;;;QAMlB;;;;WAIG;;;;;GAgBR;;;;;;;+BAEW,UAAU,CAAC,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;4BACtD,gBAAgB,CAAC,YAAY,CAAC;0BAjIrB,mBAAmB;0BACP,iBAAiB;kCAGN,+CAA+C;8BADlE,sBAAsB;mCACH,+CAA+C;gCAH1D,iBAAiB;4BACjB,aAAa"}