@agoric/orchestration 0.1.1-dev-31a57fc.0 → 0.1.1-dev-ab4941a.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/orchestration",
-  "version": "0.1.1-dev-31a57fc.0+31a57fc",
+  "version": "0.1.1-dev-ab4941a.0+ab4941a",
   "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-31a57fc.0+31a57fc",
-    "@agoric/cosmic-proto": "0.4.1-dev-31a57fc.0+31a57fc",
-    "@agoric/ertp": "0.16.3-dev-31a57fc.0+31a57fc",
-    "@agoric/internal": "0.3.3-dev-31a57fc.0+31a57fc",
-    "@agoric/network": "0.1.1-dev-31a57fc.0+31a57fc",
-    "@agoric/notifier": "0.6.3-dev-31a57fc.0+31a57fc",
-    "@agoric/store": "0.9.3-dev-31a57fc.0+31a57fc",
-    "@agoric/time": "0.3.3-dev-31a57fc.0+31a57fc",
-    "@agoric/vat-data": "0.5.3-dev-31a57fc.0+31a57fc",
-    "@agoric/vats": "0.15.2-dev-31a57fc.0+31a57fc",
-    "@agoric/vow": "0.1.1-dev-31a57fc.0+31a57fc",
-    "@agoric/zoe": "0.26.3-dev-31a57fc.0+31a57fc",
-    "@agoric/zone": "0.2.3-dev-31a57fc.0+31a57fc",
+    "@agoric/async-flow": "0.1.1-dev-ab4941a.0+ab4941a",
+    "@agoric/cosmic-proto": "0.4.1-dev-ab4941a.0+ab4941a",
+    "@agoric/ertp": "0.16.3-dev-ab4941a.0+ab4941a",
+    "@agoric/internal": "0.3.3-dev-ab4941a.0+ab4941a",
+    "@agoric/network": "0.1.1-dev-ab4941a.0+ab4941a",
+    "@agoric/notifier": "0.6.3-dev-ab4941a.0+ab4941a",
+    "@agoric/store": "0.9.3-dev-ab4941a.0+ab4941a",
+    "@agoric/time": "0.3.3-dev-ab4941a.0+ab4941a",
+    "@agoric/vat-data": "0.5.3-dev-ab4941a.0+ab4941a",
+    "@agoric/vats": "0.15.2-dev-ab4941a.0+ab4941a",
+    "@agoric/vow": "0.1.1-dev-ab4941a.0+ab4941a",
+    "@agoric/zoe": "0.26.3-dev-ab4941a.0+ab4941a",
+    "@agoric/zone": "0.2.3-dev-ab4941a.0+ab4941a",
     "@endo/base64": "^1.0.5",
     "@endo/errors": "^1.2.2",
     "@endo/far": "^1.1.2",
@@ -54,7 +54,7 @@
     "@noble/hashes": "github:paulmillr/noble-hashes#ae060da"
   },
   "devDependencies": {
-    "@agoric/swingset-liveslots": "0.10.3-dev-31a57fc.0+31a57fc",
+    "@agoric/swingset-liveslots": "0.10.3-dev-ab4941a.0+ab4941a",
     "@chain-registry/client": "^1.47.4",
     "@cosmjs/amino": "^0.32.3",
     "@cosmjs/proto-signing": "^0.32.3",
@@ -92,7 +92,7 @@
     "access": "public"
   },
   "typeCoverage": {
-    "atLeast": 97.99
+    "atLeast": 98.04
   },
-  "gitHead": "31a57fcc7ed223d138521e7bf9de090378f29962"
+  "gitHead": "ab4941a38e563ef355fadbf464e1694e02923d54"
 }

package/src/chain-info.d.ts

@@ -1,5 +1,5 @@
-export function registerChain(agoricNamesAdmin: ERef<import("@agoric/vats").NameHubKit["nameAdmin"]>, name: string, chainInfo: CosmosChainInfo, log?: ((...messages: string[]) => void) | undefined): Promise<void>;
-export function registerChainNamespace(agoricNamesAdmin: ERef<import("@agoric/vats").NameHubKit["nameAdmin"]>, log?: ((...messages: string[]) => void) | undefined): Promise<void>;
+export function registerChain(agoricNamesAdmin: ERef<import("@agoric/vats").NameHubKit["nameAdmin"]>, name: string, chainInfo: CosmosChainInfo, log?: ((...messages: string[]) => void) | undefined, handledConnections?: Set<string> | undefined): Promise<void>;
+export function registerKnownChains(agoricNamesAdmin: ERef<import("@agoric/vats").NameHubKit["nameAdmin"]>, log?: ((...messages: string[]) => void) | undefined): Promise<void>;
 export type ChainInfo = CosmosChainInfo | EthChainInfo;
 export type KnownChains = typeof knownChains;
 import type { CosmosChainInfo } from './types.js';

package/src/chain-info.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chain-info.d.ts","sourceRoot":"","sources":["chain-info.js"],"names":[],"mappings":"AAsGO,gDALI,IAAI,CAAC,OAAO,cAAc,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,QACpD,MAAM,aACN,eAAe,uBACD,MAAM,EAAE,KAAK,IAAI,8BAoCzC;AAMM,yDAHI,IAAI,CAAC,OAAO,cAAc,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,uBACtC,MAAM,EAAE,KAAK,IAAI,8BAMzC;wBA1Ia,eAAe,GAAG,YAAY;0BAyD9B,OAAO,WAAW;qCA3DoC,YAAY;kCAAZ,YAAY;AAAhF,oFAAoF;AAEpF,0DAA0D;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqDE"}
+{"version":3,"file":"chain-info.d.ts","sourceRoot":"","sources":["chain-info.js"],"names":[],"mappings":"AA2EO,gDAPI,IAAI,CAAC,OAAO,cAAc,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,QACpD,MAAM,aACN,eAAe,uBACD,MAAM,EAAE,KAAK,IAAI,4EA6CzC;AAQM,sDAHI,IAAI,CAAC,OAAO,cAAc,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,uBACtC,MAAM,EAAE,KAAK,IAAI,8BAOzC;wBAzHa,eAAe,GAAG,YAAY;0BAyD9B,OAAO,WAAW;qCA3DoC,YAAY;kCAAZ,YAAY;AAAhF,oFAAoF;AAEpF,0DAA0D;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqDE"}

package/src/chain-info.js

@@ -1,6 +1,6 @@
 import { E } from '@endo/far';
 import { mustMatch } from '@endo/patterns';
-import { connectionKey } from './exos/chain-hub.js';
+import { normalizeConnectionInfo } from './exos/chain-hub.js';
 import fetchedChainInfo from './fetched-chain-info.js'; // Refresh with scripts/refresh-chain-info.ts
 import { CosmosChainInfoShape } from './typeGuards.js';
 
@@ -65,46 +65,20 @@ const knownChains = /** @satisfies {Record<string, ChainInfo>} */ (
 
 /** @typedef {typeof knownChains} KnownChains */
 
-/**
- * Utility to reverse connection info perspective.
- *
- * @param {IBCConnectionInfo} connInfo
- * @returns {IBCConnectionInfo}
- */
-const reverseConnInfo = connInfo => {
-  const { transferChannel } = connInfo;
-  return {
-    id: connInfo.counterparty.connection_id,
-    client_id: connInfo.counterparty.client_id,
-    counterparty: {
-      client_id: connInfo.client_id,
-      connection_id: connInfo.id,
-      prefix: {
-        key_prefix: '',
-      },
-    },
-    state: connInfo.state,
-    transferChannel: {
-      ...transferChannel,
-      channelId: transferChannel.counterPartyChannelId,
-      counterPartyChannelId: transferChannel.channelId,
-      portId: transferChannel.counterPartyPortId,
-      counterPartyPortId: transferChannel.portId,
-    },
-  };
-};
-
 /**
  * @param {ERef<import('@agoric/vats').NameHubKit['nameAdmin']>} agoricNamesAdmin
  * @param {string} name
  * @param {CosmosChainInfo} chainInfo
  * @param {(...messages: string[]) => void} [log]
+ * @param {Set<string>} [handledConnections] connection keys that need not be
+ *   updated
  */
 export const registerChain = async (
   agoricNamesAdmin,
   name,
   chainInfo,
   log = () => {},
+  handledConnections = new Set(),
 ) => {
   const { nameAdmin } = await E(agoricNamesAdmin).provideChild('chain');
   const { nameAdmin: connAdmin } =
@@ -120,28 +94,37 @@ export const registerChain = async (
   ];
 
   const { chainId } = chainInfo;
-  // FIXME updates redundantly, twice per edge
   for (const [counterChainId, connInfo] of Object.entries(connections)) {
-    const key = connectionKey(chainId, counterChainId);
-    const normalizedConnInfo =
-      chainId < counterChainId ? connInfo : reverseConnInfo(connInfo);
+    const [key, connectionInfo] = normalizeConnectionInfo(
+      chainId,
+      counterChainId,
+      connInfo,
+    );
+    if (handledConnections.has(key)) {
+      continue;
+    }
 
     promises.push(
       E(connAdmin)
-        .update(key, normalizedConnInfo)
+        .update(key, connectionInfo)
         .then(() => log(`registering agoricNames chainConnection.${key}`)),
     );
+
+    handledConnections.add(key);
   }
   // Bundle to pipeline IO
   await Promise.all(promises);
 };
 
 /**
+ * Register all the chains that are known statically.
+ *
  * @param {ERef<import('@agoric/vats').NameHubKit['nameAdmin']>} agoricNamesAdmin
  * @param {(...messages: string[]) => void} [log]
  */
-export const registerChainNamespace = async (agoricNamesAdmin, log) => {
+export const registerKnownChains = async (agoricNamesAdmin, log) => {
+  const handledConnections = new Set();
   for await (const [name, info] of Object.entries(knownChains)) {
-    await registerChain(agoricNamesAdmin, name, info, log);
+    await registerChain(agoricNamesAdmin, name, info, log, handledConnections);
   }
 };

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

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

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

@@ -1 +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"}
+{"version":3,"file":"basic-flows.contract.d.ts","sourceRoot":"","sources":["basic-flows.contract.js"],"names":[],"mappings":"AAuCO,2BANI,GAAG,eACH,mBAAmB,GAAG;IAChC,UAAc,EAAE,UAAU,CAAC;CACxB,WACO,OAAO;;;uBAfM,MAAM;;;GA+C7B;2BAEa,OAAO,KAAK;yCA3DY,0BAA0B;6BAHtC,kBAAkB;yBAEZ,aAAa"}

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

@@ -9,6 +9,7 @@ import { provideOrchestration } from '../utils/start-helper.js';
 /**
  * @import {Baggage} from '@agoric/vat-data';
  * @import {Orchestrator} from '@agoric/orchestration';
+ * @import {Vow, VowTools} from '@agoric/vow';
  * @import {OrchestrationPowers} from '../utils/start-helper.js';
  */
 
@@ -44,7 +45,6 @@ export const start = async (zcf, privateArgs, baggage) => {
     privateArgs.marshaller,
   );
 
-  /** @type {OfferHandler} */
   const makeOrchAccount = orchestrate(
     'makeOrchAccount',
     undefined,

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

@@ -22,7 +22,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<{
-        makeSendInvitation(): Promise<Invitation<any, any>>;
+        makeSendInvitation(): Promise<Invitation<import("@agoric/vow").Vow<any>, any>>;
     }>;
     creatorFacet: import("@endo/exo").Guarded<{
         /**

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

@@ -13,7 +13,7 @@ export const start: (zcf: ZCF<Record<string, unknown>>, privateArgs: {
     marshaller: Marshaller;
 }, baggage: import("@agoric/vat-data").Baggage) => Promise<{
     publicFacet: import("@endo/exo").Guarded<{
-        makeSwapAndStakeInvitation(): Promise<Invitation<unknown, {
+        makeSwapAndStakeInvitation(): Promise<Invitation<import("@agoric/vow").Vow<void>, {
             staked: Amount<"nat">;
             validator: CosmosValidatorAddress;
         }>>;

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

@@ -1 +1 @@
-{"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;6BAxHvB,cAAc;4BAFf,kBAAkB;gCADd,gCAAgC;6CAEnB,sCAAsC;kCAHjD,cAAc;4CADU,aAAa"}
+{"version":3,"file":"swapExample.contract.d.ts","sourceRoot":"","sources":["swapExample.contract.js"],"names":[],"mappings":"AA6DA,yCAAyC;AACzC,mBADW,YAAY,CAAC,OAAO,KAAK,CAAC,CAWnC;AASK,0CAHI,KAAK;;;EAIsC;AA6CtD;iBAtCkB,OAAO,OAAO,CAAC;gBAChB,OAAO,UAAU,CAAC;0BACR,OAAO,uBAAuB,CAAC;iBACxC,OAAO,WAAW,CAAC;kBAClB,OAAO,YAAY,CAAC;gBACtB,UAAU;;;;oBAtEhB,MAAM,CAAC,KAAK,CAAC;uBACb,sBAAsB;;;GAsGgB;6BAlHvB,cAAc;4BAFf,kBAAkB;gCADd,gCAAgC;6CAEnB,sCAAsC;kCAHjD,cAAc;4CADU,aAAa"}

package/src/examples/swapExample.contract.js

@@ -5,7 +5,6 @@ import { orcUtils } from '../utils/orc.js';
 import { withOrchestration } from '../utils/start-helper.js';
 
 /**
- * @import {GuestInterface, GuestOf} from '@agoric/async-flow';
  * @import {LocalTransfer} from '../utils/zoe-tools.js';
  * @import {Orchestrator, CosmosValidatorAddress} from '../types.js'
  * @import {TimerService} from '@agoric/time';
@@ -102,12 +101,6 @@ const contract = async (zcf, privateArgs, zone, { orchestrate, zoeTools }) => {
   const { brands } = zcf.getTerms();
 
   /** deprecated historical example */
-  /**
-   * @type {OfferHandler<
-   *   unknown,
-   *   { staked: Amount<'nat'>; validator: CosmosValidatorAddress }
-   * >}
-   */
   const swapAndStakeHandler = orchestrate(
     'LSTTia',
     { zcf, localTransfer: zoeTools.localTransfer },

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

@@ -5,9 +5,9 @@ export const start: (zcf: ZCF<Record<string, unknown>>, privateArgs: {
     storageNode: Remote<StorageNode>;
     marshaller: Marshaller;
     timerService: Remote<TimerService>;
-}, baggage: Baggage) => Promise<{
+}, baggage: import("@agoric/vat-data").Baggage) => Promise<{
     publicFacet: import("@endo/exo").Guarded<{
-        makeUnbondAndLiquidStakeInvitation(): Promise<Invitation<unknown, never>>;
+        makeUnbondAndLiquidStakeInvitation(): Promise<Invitation<import("@agoric/vow").Vow<void>, undefined>>;
     }>;
 }>;
 import type { NameHub } from '@agoric/vats';
@@ -15,5 +15,4 @@ import type { Remote } from '@agoric/internal';
 import type { LocalChain } from '@agoric/vats/src/localchain.js';
 import type { CosmosInterchainService } from '../exos/cosmos-interchain-service.js';
 import type { TimerService } from '@agoric/time';
-import type { Baggage } from '@agoric/vat-data';
 //# sourceMappingURL=unbondExample.contract.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"unbondExample.contract.d.ts","sourceRoot":"","sources":["unbondExample.contract.js"],"names":[],"mappings":"AAuFA;iBArCkB,OAAO,OAAO,CAAC;gBAChB,OAAO,UAAU,CAAC;0BACR,OAAO,uBAAuB,CAAC;iBACxC,OAAO,WAAW,CAAC;gBACpB,UAAU;kBACR,OAAO,YAAY,CAAC;;;;;GAgCU;6BA/EvB,cAAc;4BACf,kBAAkB;gCAFd,gCAAgC;6CAInB,sCAAsC;kCANjD,cAAc;6BACnB,kBAAkB"}
+{"version":3,"file":"unbondExample.contract.d.ts","sourceRoot":"","sources":["unbondExample.contract.js"],"names":[],"mappings":"AAqFA;iBApCkB,OAAO,OAAO,CAAC;gBAChB,OAAO,UAAU,CAAC;0BACR,OAAO,uBAAuB,CAAC;iBACxC,OAAO,WAAW,CAAC;gBACpB,UAAU;kBACR,OAAO,YAAY,CAAC;;;;;GA+BU;6BA9EvB,cAAc;4BACf,kBAAkB;gCAFd,gCAAgC;6CAInB,sCAAsC;kCALjD,cAAc"}

package/src/examples/unbondExample.contract.js

@@ -4,7 +4,6 @@ import { withOrchestration } from '../utils/start-helper.js';
 /**
  * @import {Orchestrator, IcaAccount, CosmosValidatorAddress} from '../types.js'
  * @import {TimerService} from '@agoric/time';
- * @import {Baggage} from '@agoric/vat-data';
  * @import {LocalChain} from '@agoric/vats/src/localchain.js';
  * @import {NameHub} from '@agoric/vats';
  * @import {Remote} from '@agoric/internal';
@@ -59,7 +58,6 @@ const unbondAndLiquidStakeFn = async (orch, { zcf }, _seat, _offerArgs) => {
  * @param {OrchestrationTools} tools
  */
 const contract = async (zcf, privateArgs, zone, { orchestrate }) => {
-  /** @type {OfferHandler} */
   const unbondAndLiquidStake = orchestrate(
     'LSTTia',
     { zcf },

package/src/exos/chain-hub.d.ts

@@ -17,6 +17,8 @@ export const CHAIN_KEY: "chain";
 /** namehub for connection info */
 export const CONNECTIONS_KEY: "chainConnection";
 export function connectionKey(chainId1: string, chainId2: string): string;
+export function reverseConnInfo(connInfo: IBCConnectionInfo): IBCConnectionInfo;
+export function normalizeConnectionInfo(primaryChainId: string, counterChainId: string, directed: IBCConnectionInfo): [string, IBCConnectionInfo];
 export function makeChainHub(agoricNames: Remote<NameHub>, vowTools: VowTools): import("@endo/exo").Guarded<{
     /**
      * Register a new chain. The name will override a name in well known chain
@@ -38,40 +40,40 @@ export function makeChainHub(agoricNames: Remote<NameHub>, vowTools: VowTools):
      */
     getChainInfo<K extends string>(chainName: K): Vow<ActualChainInfo<K>>;
     /**
-     * @param {string} chainId1
-     * @param {string} chainId2
-     * @param {IBCConnectionInfo} connectionInfo
+     * @param {string} primaryChainId
+     * @param {string} counterpartyChainId
+     * @param {IBCConnectionInfo} connectionInfo from primary to counterparty
      */
-    registerConnection(chainId1: string, chainId2: string, connectionInfo: IBCConnectionInfo): void;
+    registerConnection(primaryChainId: string, counterpartyChainId: string, connectionInfo: IBCConnectionInfo): void;
     /**
-     * @param {string | { chainId: string }} chain1
-     * @param {string | { chainId: string }} chain2
+     * @param {string | { chainId: string }} primary the primary chain
+     * @param {string | { chainId: string }} counter the counterparty chain
      * @returns {Vow<IBCConnectionInfo>}
      */
-    getConnectionInfo(chain1: string | {
+    getConnectionInfo(primary: string | {
         chainId: string;
-    }, chain2: string | {
+    }, counter: string | {
         chainId: string;
     }): Vow<IBCConnectionInfo>;
     /**
      * @template {string} C1
      * @template {string} C2
-     * @param {C1} chainName1
-     * @param {C2} chainName2
+     * @param {C1} primaryName the primary chain name
+     * @param {C2} counterName the counterparty chain name
      * @returns {Vow<
      *   [ActualChainInfo<C1>, ActualChainInfo<C2>, IBCConnectionInfo]
      * >}
      */
-    getChainsAndConnection<C1 extends string, C2 extends string>(chainName1: C1, chainName2: C2): Vow<[ActualChainInfo<C1>, ActualChainInfo<C2>, IBCConnectionInfo]>;
+    getChainsAndConnection<C1 extends string, C2 extends string>(primaryName: C1, counterName: C2): Vow<[ActualChainInfo<C1>, ActualChainInfo<C2>, IBCConnectionInfo]>;
 }>;
 export type ActualChainInfo<K extends string> = K extends keyof KnownChains ? Omit<KnownChains[K], "connections"> : ChainInfo;
 export type ChainHub = ReturnType<typeof makeChainHub>;
+import type { IBCConnectionInfo } from '../cosmos-api.js';
 import type { NameHub } from '@agoric/vats';
 import type { Remote } from '@agoric/internal';
 import type { VowTools } from '@agoric/vow';
 import type { CosmosChainInfo } from '../cosmos-api.js';
 import type { Vow } from '@agoric/vow';
-import type { IBCConnectionInfo } from '../cosmos-api.js';
 import type { KnownChains } from '../chain-info.js';
 import type { ChainInfo } from '../chain-info.js';
 //# sourceMappingURL=chain-hub.d.ts.map

package/src/exos/chain-hub.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chain-hub.d.ts","sourceRoot":"","sources":["chain-hub.js"],"names":[],"mappings":"AAQA;;;;;;;GAOG;AAEH;;;;;GAKG;AAEH,wCAAwC;AACxC,gCAAiC;AACjC,kCAAkC;AAClC,gDAAiD;AAqB1C,wCAHI,MAAM,YACN,MAAM,UAUhB;AAoCM,0CAHI,OAAO,OAAO,CAAC,YACf,QAAQ;IAmGf;;;;;;;;;;;OAWG;wBAFQ,MAAM,aACN,eAAe;IAK1B;;;;OAIG;iBAHmB,CAAC,SAAV,MAAQ,aACV,CAAC,GACC,IAAI,eAAe,CAAC,CAAC,CAAC,CAAC;IAYpC;;;;OAIG;iCAHQ,MAAM,YACN,MAAM,kBACN,iBAAiB;IAO5B;;;;OAIG;8BAHQ,MAAM,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,UAC5B,MAAM,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAC1B,IAAI,iBAAiB,CAAC;IAanC;;;;;;;;OAQG;2BAPmB,EAAE,SAAX,MAAQ,EACC,EAAE,SAAX,MAAQ,cACV,EAAE,cACF,EAAE,GACA,IACZ,CAAK,eAAe,CAAC,EAAE,CAAC,EAAE,eAAe,CAAC,EAAE,CAAC,EAAE,iBAAiB,CAAC,CAC9D;GASP;4BAnPqB,CAAC,SAAV,MAAQ,IACR,CAAC,SAAS,MAAM,WAAW,GACjC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,GACnC,SAAS;uBAiPF,UAAU,CAAC,OAAO,YAAY,CAAC;6BA7PnB,cAAc;4BAIf,kBAAkB;8BAHX,aAAa;qCACQ,kBAAkB;yBADvC,aAAa;uCACQ,kBAAkB;iCAC9B,kBAAkB;+BAAlB,kBAAkB"}
+{"version":3,"file":"chain-hub.d.ts","sourceRoot":"","sources":["chain-hub.js"],"names":[],"mappings":"AAQA;;;;;;;GAOG;AAEH;;;;;GAKG;AAEH,wCAAwC;AACxC,gCAAiC;AACjC,kCAAkC;AAClC,gDAAiD;AAqB1C,wCAHI,MAAM,YACN,MAAM,UAUhB;AAQM,0CAHI,iBAAiB,GACf,iBAAiB,CAuB7B;AAUM,wDALI,MAAM,kBACN,MAAM,YACN,iBAAiB,GACf,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAavC;AAuDM,0CAHI,OAAO,OAAO,CAAC,YACf,QAAQ;IAoGf;;;;;;;;;;;OAWG;wBAFQ,MAAM,aACN,eAAe;IAK1B;;;;OAIG;iBAHmB,CAAC,SAAV,MAAQ,aACV,CAAC,GACC,IAAI,eAAe,CAAC,CAAC,CAAC,CAAC;IAYpC;;;;OAIG;uCAHQ,MAAM,uBACN,MAAM,kBACN,iBAAiB;IAW5B;;;;OAIG;+BAHQ,MAAM,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,WAC5B,MAAM,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAC1B,IAAI,iBAAiB,CAAC;IAmBnC;;;;;;;;OAQG;2BAPmB,EAAE,SAAX,MAAQ,EACC,EAAE,SAAX,MAAQ,eACV,EAAE,eACF,EAAE,GACA,IACZ,CAAK,eAAe,CAAC,EAAE,CAAC,EAAE,eAAe,CAAC,EAAE,CAAC,EAAE,iBAAiB,CAAC,CAC9D;GASP;4BAnUqB,CAAC,SAAV,MAAQ,IACR,CAAC,SAAS,MAAM,WAAW,GACjC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,GACnC,SAAS;uBAiUF,UAAU,CAAC,OAAO,YAAY,CAAC;uCA3UQ,kBAAkB;6BAF7C,cAAc;4BAIf,kBAAkB;8BAHX,aAAa;qCACQ,kBAAkB;yBADvC,aAAa;iCAEJ,kBAAkB;+BAAlB,kBAAkB"}

package/src/exos/chain-hub.js

@@ -56,6 +56,75 @@ export const connectionKey = (chainId1, chainId2) => {
   return [chainId1, chainId2].sort().join(CHAIN_ID_SEPARATOR);
 };
 
+/**
+ * Utility to reverse connection info perspective.
+ *
+ * @param {IBCConnectionInfo} connInfo
+ * @returns {IBCConnectionInfo}
+ */
+export const reverseConnInfo = connInfo => {
+  const { transferChannel } = connInfo;
+  return {
+    id: connInfo.counterparty.connection_id,
+    client_id: connInfo.counterparty.client_id,
+    counterparty: {
+      client_id: connInfo.client_id,
+      connection_id: connInfo.id,
+      prefix: {
+        key_prefix: 'FIXME',
+      },
+    },
+    state: connInfo.state,
+    transferChannel: {
+      ...transferChannel,
+      channelId: transferChannel.counterPartyChannelId,
+      counterPartyChannelId: transferChannel.channelId,
+      portId: transferChannel.counterPartyPortId,
+      counterPartyPortId: transferChannel.portId,
+    },
+  };
+};
+
+/**
+ * Convert the info to an undirected form.
+ *
+ * @param {string} primaryChainId
+ * @param {string} counterChainId
+ * @param {IBCConnectionInfo} directed
+ * @returns {[string, IBCConnectionInfo]}
+ */
+export const normalizeConnectionInfo = (
+  primaryChainId,
+  counterChainId,
+  directed,
+) => {
+  const key = connectionKey(primaryChainId, counterChainId);
+  if (primaryChainId < counterChainId) {
+    return [key, directed];
+  } else {
+    return [key, reverseConnInfo(directed)];
+  }
+};
+
+/**
+ * Provide a view on the connection from the primary chain's perspective.
+ *
+ * @param {string} primaryChainId
+ * @param {string} counterChainId
+ * @param {IBCConnectionInfo} normalized
+ */
+const denormalizeConnectionInfo = (
+  primaryChainId,
+  counterChainId,
+  normalized,
+) => {
+  if (primaryChainId < counterChainId) {
+    return normalized;
+  } else {
+    return reverseConnInfo(normalized);
+  }
+};
+
 const ChainIdArgShape = M.or(
   M.string(),
   M.splitRecord(
@@ -146,7 +215,8 @@ export const makeChainHub = (agoricNames, vowTools) => {
         if (!connectionInfos.has(key)) {
           connectionInfos.init(key, connectionInfo);
         }
-        return connectionInfo;
+
+        return denormalizeConnectionInfo(chainId1, chainId2, connectionInfo);
       } catch (e) {
         console.error('lookupConnectionInfo', chainId1, chainId2, 'error', e);
         throw makeError(`connection not found: ${chainId1}<->${chainId2}`);
@@ -161,26 +231,26 @@ export const makeChainHub = (agoricNames, vowTools) => {
     /**
      * @template {string} C1
      * @template {string} C2
-     * @param {C1} chainName1
-     * @param {C2} chainName2
+     * @param {C1} primaryName
+     * @param {C2} counterName
      * @returns {Promise<
      *   [ActualChainInfo<C1>, ActualChainInfo<C2>, IBCConnectionInfo]
      * >}
      */
     // eslint-disable-next-line no-restricted-syntax -- TODO more exact rules for vow best practices
-    async (chainName1, chainName2) => {
-      const [chain1, chain2] = await vowTools.asPromise(
+    async (primaryName, counterName) => {
+      const [primary, counter] = await vowTools.asPromise(
         vowTools.allVows([
-          chainHub.getChainInfo(chainName1),
-          chainHub.getChainInfo(chainName2),
+          chainHub.getChainInfo(primaryName),
+          chainHub.getChainInfo(counterName),
         ]),
       );
       const connectionInfo = await vowTools.asPromise(
-        chainHub.getConnectionInfo(chain2, chain1),
+        chainHub.getConnectionInfo(primary, counter),
       );
       return /** @type {[ActualChainInfo<C1>, ActualChainInfo<C2>, IBCConnectionInfo]} */ ([
-        chain1,
-        chain2,
+        primary,
+        counter,
         connectionInfo,
       ]);
     },
@@ -218,43 +288,53 @@ export const makeChainHub = (agoricNames, vowTools) => {
       return lookupChainInfo(chainName);
     },
     /**
-     * @param {string} chainId1
-     * @param {string} chainId2
-     * @param {IBCConnectionInfo} connectionInfo
+     * @param {string} primaryChainId
+     * @param {string} counterpartyChainId
+     * @param {IBCConnectionInfo} connectionInfo from primary to counterparty
      */
-    registerConnection(chainId1, chainId2, connectionInfo) {
-      const key = connectionKey(chainId1, chainId2);
-      connectionInfos.init(key, connectionInfo);
+    registerConnection(primaryChainId, counterpartyChainId, connectionInfo) {
+      const [key, normalized] = normalizeConnectionInfo(
+        primaryChainId,
+        counterpartyChainId,
+        connectionInfo,
+      );
+      connectionInfos.init(key, normalized);
     },
 
     /**
-     * @param {string | { chainId: string }} chain1
-     * @param {string | { chainId: string }} chain2
+     * @param {string | { chainId: string }} primary the primary chain
+     * @param {string | { chainId: string }} counter the counterparty chain
      * @returns {Vow<IBCConnectionInfo>}
      */
-    getConnectionInfo(chain1, chain2) {
-      const chainId1 = typeof chain1 === 'string' ? chain1 : chain1.chainId;
-      const chainId2 = typeof chain2 === 'string' ? chain2 : chain2.chainId;
-      const key = connectionKey(chainId1, chainId2);
+    getConnectionInfo(primary, counter) {
+      const primaryId = typeof primary === 'string' ? primary : primary.chainId;
+      const counterId = typeof counter === 'string' ? counter : counter.chainId;
+      const key = connectionKey(primaryId, counterId);
       if (connectionInfos.has(key)) {
-        return vowTools.asVow(() => connectionInfos.get(key));
+        return vowTools.asVow(() =>
+          denormalizeConnectionInfo(
+            primaryId,
+            counterId,
+            connectionInfos.get(key),
+          ),
+        );
       }
 
-      return lookupConnectionInfo(chainId1, chainId2);
+      return lookupConnectionInfo(primaryId, counterId);
     },
 
     /**
      * @template {string} C1
      * @template {string} C2
-     * @param {C1} chainName1
-     * @param {C2} chainName2
+     * @param {C1} primaryName the primary chain name
+     * @param {C2} counterName the counterparty chain name
      * @returns {Vow<
      *   [ActualChainInfo<C1>, ActualChainInfo<C2>, IBCConnectionInfo]
      * >}
      */
-    getChainsAndConnection(chainName1, chainName2) {
+    getChainsAndConnection(primaryName, counterName) {
       // @ts-expect-error XXX generic parameter propagation
-      return lookupChainsAndConnection(chainName1, chainName2);
+      return lookupChainsAndConnection(primaryName, counterName);
     },
   });
 

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":"AAsDA;;;GAGG;AAEH;;;;;;;;;GASG;AAEH,mCAAmC;AACnC;;;;;;;;;;;;;;GAaG;AAgBI,2DALI,IAAI,mBACJ,eAAe,0BACf,QAAQ,OACR,GAAG;aAwDC,UAAU;iBACV,OAAO,WAAW,CAAC;mBACnB,aAAa,GAAG,SAAS;WACzB,OAAO,YAAY,CAAC;;;QAc3B,wDAAwD;;;QAWxD;;;WAGG;6BAFQ,SAAS,GACP,IAAI;;;QAiBjB;;WAEG;8BADQ,SAAS,aAAa,CAAC,EAAE;;;QAYpC;;WAEG;4BADQ,MAAM;;IAgBnB;;;OAGG;;QAED,uDAAuD;4BAA3C,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;QAO5C,6BAA6B;4BAAjB,MAAM;;;QAYlB;;;WAGG;4BAFQ,sBAAsB,UACtB,SAAS;QAUpB;;;;WAIG;iCAHQ,sBAAsB,gBACtB,sBAAsB,UACtB,SAAS;QAYpB,gDAAgD;kCAApC,sBAAsB;QASlC,kEAAkE;gCAAtD,IAAI,CAAC,UAAU,EAAE,kBAAkB,CAAC,EAAE;;QAYlD;;;;WAIG;;;;QAMH,iEAAiE;;QAsBjE,+DAA+D;;QAiB/D,0DAA0D;;QAI1D,wDAAwD;;QAmBxD,2DAA2D;;QAK3D,0DAA0D;;QAyB1D,8DAA8D;;QAgB9D,0DAA0D;;QAsB1D,oDAAoD;;QAMpD,wDAAwD;;QAMxD,6DAA6D;;QAM7D,+DAA+D;;QAK/D,0DAA0D;;;GA6BjE;AAmBM,wDAVI,IAAI,mBACJ,eAAe,YACf,QAAQ,OACR,GAAG,GACD,CACZ,GAAO,IAAI,EAAE,UAAU,CACvB,UAAgB,CAAC,OAAO,oCAAoC,CAAC,CACxD,KACE,6BAA6B,CAAC,QAAQ,CAAC,CAe9C;;kBAvda,YAAY;;oBAIb;IACZ,QAAY,EAAE,YAAY,qCAAqC,CAAC,CAAC;IACjE,OAAW,EAAE,UAAU,CAAC;IACxB,YAAgB,EAAE,YAAY,CAAC;IAC/B,aAAiB,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7C,SAAa,EAAE,MAAM,CAAC;IACtB,KAAS,EAAE,OAAO,YAAY,CAAC,CAAC;CAC7B;4CA+aS,UAAU,CACtB,UAAc,CAAC,OAAO,oCAAoC,CAAC,CACxD;yCA4BU,6BAA6B,CAAC,QAAQ,CAAC;0BApe9B,cAAc;qCAPU,6CAA6C;8BAM5D,aAAa;kCAPqH,aAAa;gCAAb,aAAa;4BAItJ,kBAAkB;mCAJuH,aAAa;kCAMhJ,cAAc;+BANqH,aAAa;0BAExJ,kDAAkD;mCAOzC,+CAA+C;8BACpD,sBAAsB;iCAViH,aAAa;yBAO/I,aAAa;4CAPqH,aAAa;gCAGlJ,wDAAwD;8BAH6E,aAAa;iCAChI,6CAA6C"}
+{"version":3,"file":"cosmos-orchestration-account.d.ts","sourceRoot":"","sources":["cosmos-orchestration-account.js"],"names":[],"mappings":"AAsDA;;;GAGG;AAEH;;;;;;;;;GASG;AAEH,mCAAmC;AACnC;;;;;;;;;;;;;;GAaG;AAgBI,2DALI,IAAI,mBACJ,eAAe,0BACf,QAAQ,OACR,GAAG;aAwDC,UAAU;iBACV,OAAO,WAAW,CAAC;mBACnB,aAAa,GAAG,SAAS;WACzB,OAAO,YAAY,CAAC;;;QAc3B,wDAAwD;;;QAWxD;;;WAGG;6BAFQ,SAAS,GACP,IAAI;;;QAiBjB;;WAEG;8BADQ,SAAS,aAAa,CAAC,EAAE;;;QAYpC;;WAEG;4BADQ,MAAM;;IAgBnB;;;OAGG;;QAED,uDAAuD;4BAA3C,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;QAO5C,6BAA6B;4BAAjB,MAAM;;;QAYlB;;;WAGG;4BAFQ,sBAAsB,UACtB,SAAS;QAUpB;;;;WAIG;iCAHQ,sBAAsB,gBACtB,sBAAsB,UACtB,SAAS;QAYpB,gDAAgD;kCAApC,sBAAsB;QASlC,kEAAkE;gCAAtD,IAAI,CAAC,UAAU,EAAE,kBAAkB,CAAC,EAAE;;QAYlD;;;;WAIG;;;;QAMH,iEAAiE;;QAqBjE,+DAA+D;;QAiB/D,0DAA0D;;QAI1D,wDAAwD;;QAmBxD,2DAA2D;;QAK3D,0DAA0D;;QAyB1D,8DAA8D;;QAgB9D,0DAA0D;;QAsB1D,oDAAoD;;QAMpD,wDAAwD;;QAMxD,6DAA6D;;QAM7D,+DAA+D;;QAK/D,0DAA0D;;;GA6BjE;AAmBM,wDAVI,IAAI,mBACJ,eAAe,YACf,QAAQ,OACR,GAAG,GACD,CACZ,GAAO,IAAI,EAAE,UAAU,CACvB,UAAgB,CAAC,OAAO,oCAAoC,CAAC,CACxD,KACE,6BAA6B,CAAC,QAAQ,CAAC,CAe9C;;kBAtda,YAAY;;oBAIb;IACZ,QAAY,EAAE,YAAY,qCAAqC,CAAC,CAAC;IACjE,OAAW,EAAE,UAAU,CAAC;IACxB,YAAgB,EAAE,YAAY,CAAC;IAC/B,aAAiB,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7C,SAAa,EAAE,MAAM,CAAC;IACtB,KAAS,EAAE,OAAO,YAAY,CAAC,CAAC;CAC7B;4CA8aS,UAAU,CACtB,UAAc,CAAC,OAAO,oCAAoC,CAAC,CACxD;yCA4BU,6BAA6B,CAAC,QAAQ,CAAC;0BAne9B,cAAc;qCAPU,6CAA6C;8BAM5D,aAAa;kCAPqH,aAAa;gCAAb,aAAa;4BAItJ,kBAAkB;mCAJuH,aAAa;kCAMhJ,cAAc;+BANqH,aAAa;0BAExJ,kDAAkD;mCAOzC,+CAA+C;8BACpD,sBAAsB;iCAViH,aAAa;yBAO/I,aAAa;4CAPqH,aAAa;gCAGlJ,wDAAwD;8BAH6E,aAAa;iCAChI,6CAA6C"}

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

@@ -329,7 +329,6 @@ export const prepareCosmosOrchestrationAccountKit = (
               // expect this complete in the same run
               publicSubscribers: await when(holder.getPublicTopics()),
               invitationMakers,
-              holder,
             });
           });
         },

package/src/exos/local-chain-facade.d.ts

@@ -98,6 +98,7 @@ export type LocalChainFacadePowers = {
     vowTools: VowTools;
 };
 export type MakeLocalChainFacade = ReturnType<typeof prepareLocalChainFacade>;
+export type LocalChainFacade = ReturnType<MakeLocalChainFacade>;
 import type { Zone } from '@agoric/base-zone';
 import type { IBCConnectionInfo } from '../types.js';
 import type { Vow } from '@agoric/vow';

package/src/exos/local-chain-facade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"local-chain-facade.d.ts","sourceRoot":"","sources":["local-chain-facade.js"],"names":[],"mappings":"AAiIO,8CAHI,IAAI,UACJ,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;QArDzB,6DAA6D;uBAA/C,IAAI,4BAA4B,CAAC,QAAQ,CAAC,CAAC;;;QAazD;;WAEG;wCADQ,CAAC,iBAAiB,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;QAWrD;;;;;;WAMG;+BALQ,OAAO,WAAW,CAAC,wBACnB;YACV,OAAW,EAAE,iBAAiB,CAAC;YAC/B,OAAW,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;SAChC;;;;;;;;;;;;;;;;;;;;;;;;cA4BX;qCA9GY;IACZ,gCAAoC,EAAE,gCAAgC,CAAC;IACvE,aAAiB,EAAE,OAAO,uBAAuB,CAAC,CAAC;IACnD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,KAAS,EAAE,OAAO,YAAY,CAAC,CAAC;IAChC,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,QAAY,EAAE,QAAQ,CAAC;CACpB;mCA0GU,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BA5HjC,mBAAmB;uCAO0D,aAAa;yBAHjF,aAAa;kDAEoC,kCAAkC;uCAHnE,gCAAgC;kCAIoB,aAAa;4BALxF,kBAAkB;sDAIsC,kCAAkC;6CADzE,gCAAgC;kCAJ3C,cAAc;gCAEG,gCAAgC;8BAChD,aAAa"}
+{"version":3,"file":"local-chain-facade.d.ts","sourceRoot":"","sources":["local-chain-facade.js"],"names":[],"mappings":"AAiIO,8CAHI,IAAI,UACJ,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;QArDzB,6DAA6D;uBAA/C,IAAI,4BAA4B,CAAC,QAAQ,CAAC,CAAC;;;QAazD;;WAEG;wCADQ,CAAC,iBAAiB,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;QAWrD;;;;;;WAMG;+BALQ,OAAO,WAAW,CAAC,wBACnB;YACV,OAAW,EAAE,iBAAiB,CAAC;YAC/B,OAAW,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;SAChC;;;;;;;;;;;;;;;;;;;;;;;;cA4BX;qCA9GY;IACZ,gCAAoC,EAAE,gCAAgC,CAAC;IACvE,aAAiB,EAAE,OAAO,uBAAuB,CAAC,CAAC;IACnD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,KAAS,EAAE,OAAO,YAAY,CAAC,CAAC;IAChC,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,QAAY,EAAE,QAAQ,CAAC;CACpB;mCA0GU,UAAU,CAAC,OAAO,uBAAuB,CAAC;+BAC1C,UAAU,CAAC,oBAAoB,CAAC;0BA7HvB,mBAAmB;uCAO0D,aAAa;yBAHjF,aAAa;kDAEoC,kCAAkC;uCAHnE,gCAAgC;kCAIoB,aAAa;4BALxF,kBAAkB;sDAIsC,kCAAkC;6CADzE,gCAAgC;kCAJ3C,cAAc;gCAEG,gCAAgC;8BAChD,aAAa"}

package/src/exos/local-chain-facade.js

@@ -134,3 +134,4 @@ export const prepareLocalChainFacade = (zone, powers) => {
 harden(prepareLocalChainFacade);
 
 /** @typedef {ReturnType<typeof prepareLocalChainFacade>} MakeLocalChainFacade */
+/** @typedef {ReturnType<MakeLocalChainFacade>} LocalChainFacade */

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

@@ -1 +1 @@
-{"version":3,"file":"local-orchestration-account.d.ts","sourceRoot":"","sources":["local-orchestration-account.js"],"names":[],"mappings":"AA2EO,0DAPI,IAAI,mBACJ,eAAe,OACf,GAAG,gBACH,OAAO,YAAY,CAAC,mCACpB,QAAQ,YACR,QAAQ;aA6DJ,iBAAiB;aACjB,YAAY;iBACZ,OAAO,WAAW,CAAC;;;QAa1B;;;WAGG;mCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;QAYxB;;;WAGG;qCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;;;;QAiBxB;;;;;;WAMG;8BALQ,CACV,SACA,UAAgB,+CAA+C,CAAC,CAC3D,CACF;;;QAcJ;;;WAGG;6DADQ,YAAY;;;QAUvB;;;;;;;;;;WAUG;6DATQ,CACV;YAAM,eAAe,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,CAAA;SAAE,EAC7D,MAAU,CACP,iCACO;YACV,WAAe,EAAE,YAAY,CAAC;YAC9B,IAAQ,EAAE,qBAAqB,CAAC;YAChC,MAAU,EAAE,WAAW,CAAC;SACrB;;;;IA4BN;;;OAGG;;QAED;;WAEG;6BADQ,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE;;IAQvC;;;OAGG;;QAED;;WAEG;6BADQ,OAAO;;IAMpB;;;OAGG;;QAED;;;;WAIG;+BAHQ,MAAM,CAAC,KAAK,CAAC,SACb,WAAW,CAAC,OAAO,CAAC,GAClB,WAAW;;;QAOxB,iEAAiE;;QAsBjE;;;;WAIG;;QAeH,2DAA2D;;QAM3D;;WAEG;;QAiBH;;;WAGG;mCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;QAsBxB;;;;WAIG;qCAHQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC,GACX,IAAI,IAAI,GAAG,eAAe,CAAC;QAoBxC;;;;WAIG;QACH,mDAAmD;;QAOnD,oDAAoD;;QAIpD,qDAAqD;;;;;;;;;;QAIrD,kDAAkD;;;QAWlD;;;;;;;;WAQG;yBAPQ,SAAS,eAET,YAAY,6CAIV,IAAI,IAAI,CAAC;QA8BtB,6DAA6D;;;GAWpE;;aAzba,MAAM;;oBAIP;IACZ,QAAY,EAAE,YAAY,6BAA6B,CAAC,CAAC;IACzD,OAAW,EAAE,iBAAiB,CAAC;IAC/B,OAAW,EAAE,YAAY,CAAC;CACvB;+CAkbU,UAAU,CAAC,OAAO,mCAAmC,CAAC;2CACtD,UAAU,CAAC,gCAAgC,CAAC;0BA5cnC,cAAc;qCADU,6CAA6C;kCAIhC,cAAc;4BAFjD,kBAAkB;8BAGC,aAAa;8BAG9B,gBAAgB;uCAVP,gCAAgC;kCACqF,uBAAuB;yBAMpI,aAAa;qCADG,cAAc;+BAEpC,sBAAsB;8BAAtB,sBAAsB;+BAP6F,uBAAuB;uCAAvB,uBAAuB;2CAAvB,uBAAuB;iCAAvB,uBAAuB;+BAAvB,uBAAuB;iCACjI,6CAA6C"}
+{"version":3,"file":"local-orchestration-account.d.ts","sourceRoot":"","sources":["local-orchestration-account.js"],"names":[],"mappings":"AA2EO,0DAPI,IAAI,mBACJ,eAAe,OACf,GAAG,gBACH,OAAO,YAAY,CAAC,mCACpB,QAAQ,YACR,QAAQ;aA6DJ,iBAAiB;aACjB,YAAY;iBACZ,OAAO,WAAW,CAAC;;;QAa1B;;;WAGG;mCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;QAYxB;;;WAGG;qCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;;;;QAiBxB;;;;;;WAMG;8BALQ,CACV,SACA,UAAgB,+CAA+C,CAAC,CAC3D,CACF;;;QAcJ;;;WAGG;6DADQ,YAAY;;;QAUvB;;;;;;;;;;WAUG;6DATQ,CACV;YAAM,eAAe,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,CAAA;SAAE,EAC7D,MAAU,CACP,iCACO;YACV,WAAe,EAAE,YAAY,CAAC;YAC9B,IAAQ,EAAE,qBAAqB,CAAC;YAChC,MAAU,EAAE,WAAW,CAAC;SACrB;;;;IA4BN;;;OAGG;;QAED;;WAEG;6BADQ,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE;;IAQvC;;;OAGG;;QAED;;WAEG;6BADQ,OAAO;;IAMpB;;;OAGG;;QAED;;;;WAIG;+BAHQ,MAAM,CAAC,KAAK,CAAC,SACb,WAAW,CAAC,OAAO,CAAC,GAClB,WAAW;;;QAOxB,iEAAiE;;QAqBjE;;;;WAIG;;QAeH,2DAA2D;;QAM3D;;WAEG;;QAiBH;;;WAGG;mCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;QAsBxB;;;;WAIG;qCAHQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC,GACX,IAAI,IAAI,GAAG,eAAe,CAAC;QAoBxC;;;;WAIG;QACH,mDAAmD;;QAOnD,oDAAoD;;QAIpD,qDAAqD;;;;;;;;;;QAIrD,kDAAkD;;;QAWlD;;;;;;;;WAQG;yBAPQ,SAAS,eAET,YAAY,6CAIV,IAAI,IAAI,CAAC;QA8BtB,6DAA6D;;;GAWpE;;aAxba,MAAM;;oBAIP;IACZ,QAAY,EAAE,YAAY,6BAA6B,CAAC,CAAC;IACzD,OAAW,EAAE,iBAAiB,CAAC;IAC/B,OAAW,EAAE,YAAY,CAAC;CACvB;+CAibU,UAAU,CAAC,OAAO,mCAAmC,CAAC;2CACtD,UAAU,CAAC,gCAAgC,CAAC;0BA3cnC,cAAc;qCADU,6CAA6C;kCAIhC,cAAc;4BAFjD,kBAAkB;8BAGC,aAAa;8BAG9B,gBAAgB;uCAVP,gCAAgC;kCACqF,uBAAuB;yBAMpI,aAAa;qCADG,cAAc;+BAEpC,sBAAsB;8BAAtB,sBAAsB;+BAP6F,uBAAuB;uCAAvB,uBAAuB;2CAAvB,uBAAuB;iCAAvB,uBAAuB;+BAAvB,uBAAuB;iCACjI,6CAA6C"}

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

@@ -307,7 +307,6 @@ export const prepareLocalOrchestrationAccountKit = (
               // expect this complete in the same run
               publicSubscribers: await when(holder.getPublicTopics()),
               invitationMakers,
-              holder,
             });
           });
         },

package/src/exos/remote-chain-facade.d.ts

@@ -98,6 +98,7 @@ export type RemoteChainFacadePowers = {
     vowTools: VowTools;
 };
 export type MakeRemoteChainFacade = ReturnType<typeof prepareRemoteChainFacade>;
+export type RemoteChainFacade = ReturnType<MakeRemoteChainFacade>;
 import type { Zone } from '@agoric/base-zone';
 import type { IBCConnectionInfo } from '../types.js';
 import type { HostInterface } from '@agoric/async-flow';

package/src/exos/remote-chain-facade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote-chain-facade.d.ts","sourceRoot":"","sources":["remote-chain-facade.js"],"names":[],"mappings":"AA2KO,+CAHI,IAAI,UACJ,uBAAuB;;;;;;;;;;;;;;;;QAnF1B,4CAA4C;;QAK5C,2CAA2C;;;;QAqB3C;;;;WAIG;6BADQ,UAAU;;;;;;;;;;;;;;;;;QAWrB;;;WAGG;kCAFQ,YAAY,WACZ,UAAU;;;;;;;;;;;;;;;;;QAWrB;;;;;;WAMG;+BALQ,OAAO,WAAW,CAAC,6BACnB;YACV,OAAW,EAAE,UAAU,CAAC;YACxB,YAAgB,EAAE,YAAY,CAAC;SAC5B;;;;;;;;;;;;;;;;cA8BX;sCApJY;IACZ,8BAAkC,EAAE,UAAU,CAC9C,wCAA8C,CACzC,CAAC;IACN,aAAiB,EAAE,OAAO,uBAAuB,CAAC,CAAC;IACnD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,KAAS,EAAE,OAAO,YAAY,CAAC,CAAC;IAChC,QAAY,EAAE,QAAQ,CAAC;CACpB;oCA+IU,UAAU,CAAC,OAAO,wBAAwB,CAAC;0BAvKlC,mBAAmB;uCAMoF,aAAa;mCAPnG,oBAAoB;yBAI5B,aAAa;0CAGiF,aAAa;gCAAb,aAAa;kCAAb,aAAa;4BAJlH,kBAAkB;uDAGS,mCAAmC;6CAD7C,gCAAgC;kCAH3C,cAAc;8BAEb,aAAa"}
+{"version":3,"file":"remote-chain-facade.d.ts","sourceRoot":"","sources":["remote-chain-facade.js"],"names":[],"mappings":"AA2KO,+CAHI,IAAI,UACJ,uBAAuB;;;;;;;;;;;;;;;;QAnF1B,4CAA4C;;QAK5C,2CAA2C;;;;QAqB3C;;;;WAIG;6BADQ,UAAU;;;;;;;;;;;;;;;;;QAWrB;;;WAGG;kCAFQ,YAAY,WACZ,UAAU;;;;;;;;;;;;;;;;;QAWrB;;;;;;WAMG;+BALQ,OAAO,WAAW,CAAC,6BACnB;YACV,OAAW,EAAE,UAAU,CAAC;YACxB,YAAgB,EAAE,YAAY,CAAC;SAC5B;;;;;;;;;;;;;;;;cA8BX;sCApJY;IACZ,8BAAkC,EAAE,UAAU,CAC9C,wCAA8C,CACzC,CAAC;IACN,aAAiB,EAAE,OAAO,uBAAuB,CAAC,CAAC;IACnD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,KAAS,EAAE,OAAO,YAAY,CAAC,CAAC;IAChC,QAAY,EAAE,QAAQ,CAAC;CACpB;oCA+IU,UAAU,CAAC,OAAO,wBAAwB,CAAC;gCAC3C,UAAU,CAAC,qBAAqB,CAAC;0BAxKxB,mBAAmB;uCAMoF,aAAa;mCAPnG,oBAAoB;yBAI5B,aAAa;0CAGiF,aAAa;gCAAb,aAAa;kCAAb,aAAa;4BAJlH,kBAAkB;uDAGS,mCAAmC;6CAD7C,gCAAgC;kCAH3C,cAAc;8BAEb,aAAa"}

package/src/exos/remote-chain-facade.js

@@ -176,3 +176,4 @@ export const prepareRemoteChainFacade = (zone, powers) => {
 harden(prepareRemoteChainFacade);
 
 /** @typedef {ReturnType<typeof prepareRemoteChainFacade>} MakeRemoteChainFacade */
+/** @typedef {ReturnType<MakeRemoteChainFacade>} RemoteChainFacade */

package/src/facade.d.ts

@@ -14,11 +14,11 @@ export function makeOrchestrationFacade({ zone, timerService, zcf, storageNode,
         wakeAll(): void;
         getFlowForOutcomeVow(outcomeVow: any): any;
     }>;
-    orchestrate: <GuestReturn, HostReturn, GuestContext, HostContext, GuestArgs extends any[], HostArgs extends any[]>(durableName: string, hostCtx: HostContext, guestFn: (guestOrc: Orchestrator, guestCtx: GuestContext, ...args: GuestArgs) => Promise<GuestReturn>) => (...args: HostArgs) => Promise<HostReturn>;
+    orchestrate: <GR, HC, GA extends any[]>(durableName: string, hostCtx: HC, guestFn: (guestOrc: Orchestrator, guestCtx: GuestInterface<HC>, ...args: GA) => Promise<GR>) => (...args: HostArgs<GA>) => Vow<GR>;
     orchestrateAll: (guestFns: {
         [durableName: string]: (...args: any[]) => any;
     }, hostCtx: any) => {
-        [k: string]: (...args: any[]) => Promise<any>;
+        [k: string]: (...args: any[]) => Vow<any>;
     };
 };
 export type OrchestrationFacade = ReturnType<typeof makeOrchestrationFacade>;
@@ -31,4 +31,7 @@ import type { HostOrchestrator } from './exos/orchestrator.js';
 import type { VowTools } from '@agoric/vow';
 import type { AsyncFlowTools } from '@agoric/async-flow';
 import type { Orchestrator } from './types.js';
+import type { GuestInterface } from '@agoric/async-flow';
+import type { HostArgs } from '@agoric/async-flow';
+import type { Vow } from '@agoric/vow';
 //# sourceMappingURL=facade.d.ts.map

package/src/facade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"facade.d.ts","sourceRoot":"","sources":["facade.js"],"names":[],"mappings":"AA6BO,sKAZI;IACV,IAAQ,EAAE,IAAI,CAAC;IACf,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,GAAO,EAAE,GAAG,CAAC;IACb,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,oBAAwB,EAAE,OAAO,uBAAuB,CAAC,CAAC;IAC1D,eAAmB,EAAE,eAAe,CAAC;IACrC,gBAAoB,EAAE,MAAM,gBAAgB,CAAC;IAC7C,QAAY,EAAE,QAAQ,CAAC;IACvB,cAAkB,EAAE,cAAc,CAAC;CAChC;;;;;;kBA8BW,WAAW,EACX,UAAU,EACV,YAAY,EACZ,WAAW,EACH,SAAS,SAAhB,GAAG,EAAG,EACC,QAAQ,SAAf,GAAG,EAAG,eACT,MAAM,WAEN,WAAW,WAEX,CACV,QAAY,EAAE,YAAY,EAC1B,QAAY,EAAE,YAAY,EAC1B,GAAO,IAAI,EAAE,SAAS,KACf,OAAO,CAAC,WAAW,CAAC,KACf,CAAC,GAAG,IAAI,EAAE,QAAQ,KAAK,OAAO,CAAC,UAAU,CAAC;+BA4B5C;QAAE,CAAC,WAAW,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAA;KAAE,WAClD,GAAG;yCA7BsB,OAAO,KAAY;;EA4CxD;kCAEa,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BAhHjC,cAAc;kCAEN,cAAc;4BAGpB,kBAAkB;6CACD,qCAAqC;qCAHhC,6CAA6C;sCACzD,wBAAwB;8BAH3B,aAAa;oCAFZ,oBAAoB;kCAQsD,YAAY"}
+{"version":3,"file":"facade.d.ts","sourceRoot":"","sources":["facade.js"],"names":[],"mappings":"AA6BO,sKAZI;IACV,IAAQ,EAAE,IAAI,CAAC;IACf,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,GAAO,EAAE,GAAG,CAAC;IACb,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,oBAAwB,EAAE,OAAO,uBAAuB,CAAC,CAAC;IAC1D,eAAmB,EAAE,eAAe,CAAC;IACrC,gBAAoB,EAAE,MAAM,gBAAgB,CAAC;IAC7C,QAAY,EAAE,QAAQ,CAAC;IACvB,cAAkB,EAAE,cAAc,CAAC;CAChC;;;;;;kBA4BW,EAAE,EACF,EAAE,EACM,EAAE,SAAT,GAAG,EAAG,eACT,MAAM,WAEN,EAAE,WACF,CACV,QAAY,EAAE,YAAY,EAC1B,QAAY,EAAE,eAAe,EAAE,CAAC,EAChC,GAAO,IAAI,EAAE,EAAE,KACR,OAAO,CAAC,EAAE,CAAC,KACN,CAAC,GAAG,IAAI,EAAE,SAAS,EAAE,CAAC,KAAK,IAAI,EAAE,CAAC;+BA2BpC;QAAE,CAAC,WAAW,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAA;KAAE,WAClD,GAAG;yCA5B0B,QAAO;;EA2ChD;kCAEa,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BAzGjC,cAAc;kCAEN,cAAc;4BAGpB,kBAAkB;6CACD,qCAAqC;qCAHhC,6CAA6C;sCACzD,wBAAwB;8BAH3B,aAAa;oCAFc,oBAAoB;kCAQ4B,YAAY;oCAR5D,oBAAoB;8BAApB,oBAAoB;yBAE/C,aAAa"}

package/src/facade.js

@@ -3,7 +3,7 @@
 import { assertAllDefined } from '@agoric/internal';
 
 /**
- * @import {AsyncFlowTools} from '@agoric/async-flow';
+ * @import {AsyncFlowTools, GuestInterface, HostArgs} from '@agoric/async-flow';
  * @import {Zone} from '@agoric/zone';
  * @import {Vow, VowTools} from '@agoric/vow';
  * @import {TimerService} from '@agoric/time';
@@ -52,27 +52,19 @@ export const makeOrchestrationFacade = ({
 
   const { prepareEndowment, asyncFlow, adminAsyncFlow } = asyncFlowTools;
 
-  const { when } = vowTools;
-
   /**
-   * @template GuestReturn
-   * @template HostReturn
-   * @template GuestContext
-   * @template HostContext
-   * @template {any[]} GuestArgs
-   * @template {any[]} HostArgs
+   * @template GR - return type
+   * @template HC - host context
+   * @template {any[]} GA - guest args
    * @param {string} durableName - the orchestration flow identity in the zone
    *   (to resume across upgrades)
-   * @param {HostContext} hostCtx - values to pass through the async flow
-   *   membrane
+   * @param {HC} hostCtx - values to pass through the async flow membrane
    * @param {(
    *   guestOrc: Orchestrator,
-   *   guestCtx: GuestContext,
-   *   ...args: GuestArgs
-   * ) => Promise<GuestReturn>} guestFn
-   * @returns {(...args: HostArgs) => Promise<HostReturn>} TODO returns a
-   *   Promise for now for compat before use of asyncFlow. But really should be
-   *   `Vow<HostReturn>`
+   *   guestCtx: GuestInterface<HC>,
+   *   ...args: GA
+   * ) => Promise<GR>} guestFn
+   * @returns {(...args: HostArgs<GA>) => Vow<GR>}
    */
   const orchestrate = (durableName, hostCtx, guestFn) => {
     const subZone = zone.subZone(durableName);
@@ -86,10 +78,11 @@ export const makeOrchestrationFacade = ({
 
     const hostFn = asyncFlow(subZone, 'asyncFlow', guestFn);
 
-    const orcFn = (...args) =>
-      // TODO remove the `when` after fixing the return type
-      // to `Vow<HostReturn>`
-      when(hostFn(wrappedOrc, wrappedCtx, ...args));
+    // cast because return could be arbitrary subtype
+    const orcFn = /** @type {(...args: HostArgs<GA>) => Vow<GR>} */ (
+      (...args) => hostFn(wrappedOrc, wrappedCtx, ...args)
+    );
+
     return harden(orcFn);
   };
 

package/src/proposals/orchestration-proposal.js

@@ -2,7 +2,7 @@ import { Fail } from '@endo/errors';
 import { E, Far } from '@endo/far';
 import { makeMarshal } from '@endo/marshal';
 import { makeTracer } from '@agoric/internal';
-import { registerChainNamespace } from '../chain-info.js';
+import { registerKnownChains } from '../chain-info.js';
 import { CHAIN_KEY, CONNECTIONS_KEY } from '../exos/chain-hub.js';
 
 const trace = makeTracer('CoreEvalOrchestration', true);
@@ -127,7 +127,7 @@ export const initChainInfo = async ({
   await publishChainInfoToChainStorage(agoricNamesAdmin, chainStorageP);
 
   // Now register the names
-  await registerChainNamespace(agoricNamesAdmin, trace);
+  await registerKnownChains(agoricNamesAdmin, trace);
 };
 harden(initChainInfo);
 

package/src/typeGuards.d.ts

@@ -1,6 +1,7 @@
 /**
  * @import {TypedPattern} from '@agoric/internal';
- * @import {CosmosChainInfo} from './cosmos-api.js';
+ * @import {ChainAddress, ChainInfo, CosmosChainInfo, DenomAmount} from './types.js';
+ * @import {Delegation} from '@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js';
  */
 /**
  * Used for IBC Channel Connections that only send outgoing transactions. If
@@ -11,50 +12,40 @@ export const OutboundConnectionHandlerI: import("@endo/patterns").InterfaceGuard
     onOpen: import("@endo/patterns").MethodGuard;
     onClose: import("@endo/patterns").MethodGuard;
 }>;
-export namespace ChainAddressShape {
-    let chainId: import("@endo/patterns").Matcher;
-    let encoding: import("@endo/patterns").Matcher;
+/** @type {TypedPattern<ChainAddress>} */
+export const ChainAddressShape: TypedPattern<ChainAddress>;
+export namespace Proto3Shape {
+    let typeUrl: import("@endo/patterns").Matcher;
     let value: import("@endo/patterns").Matcher;
 }
-export namespace Proto3Shape {
-    export let typeUrl: import("@endo/patterns").Matcher;
+export namespace CoinShape {
     let value_1: import("@endo/patterns").Matcher;
     export { value_1 as value };
-}
-export namespace CoinShape {
-    let value_2: import("@endo/patterns").Matcher;
-    export { value_2 as value };
     export let denom: import("@endo/patterns").Matcher;
 }
 export namespace ChainAmountShape {
     let denom_1: import("@endo/patterns").Matcher;
     export { denom_1 as denom };
-    let value_3: import("@endo/patterns").Matcher;
-    export { value_3 as value };
+    let value_2: import("@endo/patterns").Matcher;
+    export { value_2 as value };
 }
 export const AmountArgShape: import("@endo/patterns").Matcher;
-export namespace DelegationShape {
-    let validatorAddress: import("@endo/patterns").Matcher;
-    let shares: import("@endo/patterns").Matcher;
-}
+/** @type {TypedPattern<Delegation>} */
+export const DelegationShape: TypedPattern<Delegation>;
 export const IBCTransferOptionsShape: import("@endo/patterns").Matcher;
 export const IBCChannelIDShape: import("@endo/patterns").Matcher;
 export const IBCChannelInfoShape: import("@endo/patterns").Matcher;
 export const IBCConnectionIDShape: import("@endo/patterns").Matcher;
 export const IBCConnectionInfoShape: import("@endo/patterns").Matcher;
-/**
- * @type {TypedPattern<CosmosChainInfo>}
- */
+/** @type {TypedPattern<CosmosChainInfo>} */
 export const CosmosChainInfoShape: TypedPattern<CosmosChainInfo>;
-export const ChainInfoShape: import("@endo/patterns").Matcher;
+/** @type {TypedPattern<ChainInfo>} */
+export const ChainInfoShape: TypedPattern<ChainInfo>;
 export const LocalChainAccountShape: import("@endo/patterns").Matcher;
 export const DenomShape: import("@endo/patterns").Matcher;
 export const BrandInfoShape: import("@endo/patterns").Matcher;
-export namespace DenomAmountShape {
-    export { DenomShape as denom };
-    let value_4: import("@endo/patterns").Matcher;
-    export { value_4 as value };
-}
+/** @type {TypedPattern<DenomAmount>} */
+export const DenomAmountShape: TypedPattern<DenomAmount>;
 /** @see {Chain} */
 export const ChainFacadeI: import("@endo/patterns").InterfaceGuard<{
     getChainInfo: import("@endo/patterns").MethodGuard;
@@ -64,6 +55,10 @@ export namespace TimestampProtoShape {
     let seconds: import("@endo/patterns").Matcher;
     let nanos: import("@endo/patterns").Matcher;
 }
-import type { CosmosChainInfo } from './cosmos-api.js';
+import type { ChainAddress } from './types.js';
 import type { TypedPattern } from '@agoric/internal';
+import type { Delegation } from '@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js';
+import type { CosmosChainInfo } from './types.js';
+import type { ChainInfo } from './types.js';
+import type { DenomAmount } from './types.js';
 //# sourceMappingURL=typeGuards.d.ts.map

package/src/typeGuards.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;GAIG;AACH;;;GAQE;;;;;;;;;;;;;;;;;;;;;;AAiBF,8DAAkE;;;;;AAOlE,uEAUE;AAEF,iEAA4C;AAC5C,mEAQG;AACH,oEAA+C;AAC/C,sEAYG;AAEH;;GAEG;AACH,mCAFU,aAAa,eAAe,CAAC,CAYrC;AAGF,8DAAsC;AACtC,sEAAuE;AACvE,0DAAqC;AAErC,8DAAsC;;;;;;AAItC,mBAAmB;AACnB;;;GAGG;;;;;qCAzG+B,iBAAiB;kCADpB,kBAAkB"}
+{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAIA;;;;GAIG;AAEH;;;;GAIG;AACH;;;GAQE;AAEF,yCAAyC;AACzC,gCADW,aAAa,YAAY,CAAC,CAKnC;;;;;;;;;;;;;;;;AAYF,8DAAkE;AAGlE,uCAAuC;AACvC,8BADW,aAAa,UAAU,CAAC,CAIhC;AAEH,uEAUE;AAEF,iEAA4C;AAC5C,mEAQG;AACH,oEAA+C;AAC/C,sEAYG;AAEH,4CAA4C;AAC5C,mCADW,aAAa,eAAe,CAAC,CAWtC;AAEF,sCAAsC;AACtC,6BADW,aAAa,SAAS,CAAC,CAG/B;AACH,sEAAuE;AACvE,0DAAqC;AAErC,8DAAsC;AAEtC,wCAAwC;AACxC,+BADW,aAAa,WAAW,CAAC,CACqC;AAEzE,mBAAmB;AACnB;;;GAGG;;;;;kCA/GqE,YAAY;kCADrD,kBAAkB;gCAEpB,wDAAwD;qCADb,YAAY;+BAAZ,YAAY;iCAAZ,YAAY"}

package/src/typeGuards.js

@@ -4,7 +4,8 @@ import { M } from '@endo/patterns';
 
 /**
  * @import {TypedPattern} from '@agoric/internal';
- * @import {CosmosChainInfo} from './cosmos-api.js';
+ * @import {ChainAddress, ChainInfo, CosmosChainInfo, DenomAmount} from './types.js';
+ * @import {Delegation} from '@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js';
  */
 
 /**
@@ -22,6 +23,7 @@ export const OutboundConnectionHandlerI = M.interface(
   },
 );
 
+/** @type {TypedPattern<ChainAddress>} */
 export const ChainAddressShape = {
   chainId: M.string(),
   encoding: M.string(),
@@ -33,12 +35,15 @@ export const Proto3Shape = {
   value: M.string(),
 };
 
+// XXX same as ChainAmountShape and DenomAmount type
 export const CoinShape = { value: M.bigint(), denom: M.string() };
 
 export const ChainAmountShape = harden({ denom: M.string(), value: M.nat() });
 
 export const AmountArgShape = M.or(AmountShape, ChainAmountShape);
 
+// FIXME missing `delegatorAddress` from the type
+/** @type {TypedPattern<Delegation>} */
 export const DelegationShape = harden({
   validatorAddress: M.string(),
   shares: M.string(), // TODO: bigint?
@@ -81,9 +86,7 @@ export const IBCConnectionInfoShape = M.splitRecord({
   transferChannel: IBCChannelInfoShape,
 });
 
-/**
- * @type {TypedPattern<CosmosChainInfo>}
- */
+/** @type {TypedPattern<CosmosChainInfo>} */
 export const CosmosChainInfoShape = M.splitRecord(
   {
     chainId: M.string(),
@@ -96,13 +99,16 @@ export const CosmosChainInfoShape = M.splitRecord(
   },
 );
 
-// FIXME more validation
-export const ChainInfoShape = M.any();
+/** @type {TypedPattern<ChainInfo>} */
+export const ChainInfoShape = M.splitRecord({
+  chainId: M.string(),
+});
 export const LocalChainAccountShape = M.remotable('LocalChainAccount');
 export const DenomShape = M.string();
-// FIXME more validation
+// TODO define for #9211
 export const BrandInfoShape = M.any();
 
+/** @type {TypedPattern<DenomAmount>} */
 export const DenomAmountShape = { denom: DenomShape, value: M.bigint() };
 
 /** @see {Chain} */

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

@@ -2,13 +2,13 @@ export function provideOrchestration(zcf: ZCF, baggage: Baggage, remotePowers: O
     chainHub: import("@endo/exo").Guarded<{
         registerChain(name: string, chainInfo: import("../cosmos-api.js").CosmosChainInfo): void;
         getChainInfo<K extends string>(chainName: K): import("@agoric/vow").Vow<ActualChainInfo<K>>;
-        registerConnection(chainId1: string, chainId2: string, connectionInfo: import("../cosmos-api.js").IBCConnectionInfo): void;
-        getConnectionInfo(chain1: string | {
+        registerConnection(primaryChainId: string, counterpartyChainId: string, connectionInfo: import("../cosmos-api.js").IBCConnectionInfo): void;
+        getConnectionInfo(primary: string | {
             chainId: string;
-        }, chain2: string | {
+        }, counter: string | {
             chainId: string;
         }): import("@agoric/vow").Vow<import("../cosmos-api.js").IBCConnectionInfo>;
-        getChainsAndConnection<C1 extends string, C2 extends string>(chainName1: C1, chainName2: C2): import("@agoric/vow").Vow<[ActualChainInfo<C1>, ActualChainInfo<C2>, import("../cosmos-api.js").IBCConnectionInfo]>;
+        getChainsAndConnection<C1 extends string, C2 extends string>(primaryName: C1, counterName: C2): import("@agoric/vow").Vow<[ActualChainInfo<C1>, ActualChainInfo<C2>, import("../cosmos-api.js").IBCConnectionInfo]>;
     }>;
     vowTools: {
         when: <T, TResult1 = import("@agoric/vow").EUnwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").EUnwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
@@ -28,11 +28,11 @@ export function provideOrchestration(zcf: ZCF, baggage: Baggage, remotePowers: O
         wakeAll(): void;
         getFlowForOutcomeVow(outcomeVow: any): any;
     }>;
-    orchestrate: <GuestReturn, HostReturn, GuestContext, HostContext, GuestArgs extends any[], HostArgs extends any[]>(durableName: string, hostCtx: HostContext, guestFn: (guestOrc: import("../orchestration-api.js").Orchestrator, guestCtx: GuestContext, ...args: GuestArgs) => Promise<GuestReturn>) => (...args: HostArgs) => Promise<HostReturn>;
+    orchestrate: <GR, HC, GA extends any[]>(durableName: string, hostCtx: HC, guestFn: (guestOrc: import("../orchestration-api.js").Orchestrator, guestCtx: import("@agoric/async-flow").GuestInterface<HC>, ...args: GA) => Promise<GR>) => (...args: import("@agoric/async-flow").HostArgs<GA>) => import("@agoric/vow").Vow<GR>;
     orchestrateAll: (guestFns: {
         [durableName: string]: (...args: any[]) => any;
     }, hostCtx: any) => {
-        [k: string]: (...args: any[]) => Promise<any>;
+        [k: string]: (...args: any[]) => import("@agoric/vow").Vow<any>;
     };
 };
 export function withOrchestration<CT extends Record<string, unknown>, PA extends OrchestrationPowers & {

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

@@ -1 +1 @@
-{"version":3,"file":"start-helper.d.ts","sourceRoot":"","sources":["start-helper.js"],"names":[],"mappings":"AA8CO,0CALI,GAAG,WACH,OAAO,gBACP,mBAAmB,cACnB,UAAU;;;;;;;;;;;;;;;;;wCA+B+B,GAAG;;+BAjDjD,GAAG,+EAIY,GAAG,yCACA,GAAG;;;;;;;;;;;8PAsBrB,GACF,8CAImB,GAAG;;gCAiCxB,GAAE;;;;EAyDH;AAuBM,kCAdgC,EAAE,SAA3B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAE,EAGhC,EAAE,SAFM,mBAAmB,GAAG;IACnC,UAAc,EAAE,UAAU,CAAC;CACvB,EACQ,CAAC,cACH,CACV,GAAO,EAAE,GAAG,CAAC,EAAE,CAAC,EAChB,WAAe,EAAE,EAAE,EACnB,IAAQ,EAAE,IAAI,EACd,KAAS,EAAE,kBAAkB,KACtB,OAAO,CAAC,CAAC,CAAC,GACL,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,CAYzE;kCA1JU;IACZ,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,oBAAwB,EAAE,OAAO,uBAAuB,CAAC,CAAC;IAC1D,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;CAC9B;iCAuHU,IAAI,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,EAAE,MAAM,CAAC;6BArIzC,kBAAkB;0BAGrB,cAAc;gCALR,gCAAgC;4BAIpC,aAAa;6CAEI,sCAAsC;kCALrC,cAAc;6BAE/B,cAAc"}
+{"version":3,"file":"start-helper.d.ts","sourceRoot":"","sources":["start-helper.js"],"names":[],"mappings":"AA8CO,0CALI,GAAG,WACH,OAAO,gBACP,mBAAmB,cACnB,UAAU;;;;;;;;;;;;;;;;;wCA+B+B,GAAG;;+BAjDjD,GAAG,+EAIY,GAAG,yCACA,GAAG;;;;;;;;;;;6MAgBvB,GACI,8BAIQ,GAAG;;gCA0B6C,GAAG;;;;EAsElE;AAuBM,kCAdgC,EAAE,SAA3B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAE,EAGhC,EAAE,SAFM,mBAAmB,GAAG;IACnC,UAAc,EAAE,UAAU,CAAC;CACvB,EACQ,CAAC,cACH,CACV,GAAO,EAAE,GAAG,CAAC,EAAE,CAAC,EAChB,WAAe,EAAE,EAAE,EACnB,IAAQ,EAAE,IAAI,EACd,KAAS,EAAE,kBAAkB,KACtB,OAAO,CAAC,CAAC,CAAC,GACL,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,CAYzE;kCA1JU;IACZ,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,oBAAwB,EAAE,OAAO,uBAAuB,CAAC,CAAC;IAC1D,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;CAC9B;iCAuHU,IAAI,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,EAAE,MAAM,CAAC;6BArIzC,kBAAkB;0BAGrB,cAAc;gCALR,gCAAgC;4BAIpC,aAAa;6CAEI,sCAAsC;kCALrC,cAAc;6BAE/B,cAAc"}