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

package/src/service.d.ts

@@ -1,12 +1,55 @@
-export const OrchestrationI: import("@endo/patterns").InterfaceGuard<{
-    makeAccount: import("@endo/patterns").MethodGuard;
-    provideICQConnection: import("@endo/patterns").MethodGuard;
-}>;
-export function prepareOrchestrationTools(zone: Zone): {
+export function prepareOrchestrationTools(zone: Zone, vowTools: {
+    when: <T, TResult1 = import("@agoric/vow").EUnwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").EUnwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
+    watch: <T_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[]>;
+}): {
     makeOrchestrationKit: (initialPowers?: Partial<OrchestrationPowers> | undefined) => import("@endo/exo").GuardedKit<{
-        self: {
-            allocateICAControllerPort(): Promise<Port>;
-            allocateICQControllerPort(): Promise<Port>;
+        requestICAChannelWatcher: {
+            /**
+             * @param {Port} port
+             * @param {{
+             *   chainId: string;
+             *   remoteConnAddr: RemoteIbcAddress;
+             * }} watchContext
+             */
+            onFulfilled(port: Port, { chainId, remoteConnAddr }: {
+                chainId: string;
+                remoteConnAddr: `/${string}ibc-port/${string}/ordered/${string}` | `/${string}ibc-port/${string}/unordered/${string}`;
+            }): import("@agoric/vow").Vow<any>;
+        };
+        requestICQChannelWatcher: {
+            /**
+             * @param {Port} port
+             * @param {{
+             *   remoteConnAddr: RemoteIbcAddress;
+             *   controllerConnectionId: IBCConnectionID;
+             * }} watchContext
+             */
+            onFulfilled(port: Port, { remoteConnAddr, controllerConnectionId }: {
+                remoteConnAddr: `/${string}ibc-port/${string}/ordered/${string}` | `/${string}ibc-port/${string}/unordered/${string}`;
+                controllerConnectionId: `connection-${number}`;
+            }): import("@agoric/vow").Vow<any>;
+        };
+        /**
+         * Waits for a channel (ICA, ICQ) to open and returns the consumer-facing
+         * facet of the ConnectionKit, specified by `returnFacet`. Saves the
+         * ConnectionKit if `saveICQConnection` is provided.
+         */
+        channelOpenWatcher: {
+            /**
+             * @param {Connection} _connection
+             * @param {{
+             *   connectionKit: ConnectionKit;
+             *   returnFacet: string;
+             *   saveICQConnection?: IBCConnectionID;
+             * }} watchContext
+             */
+            onFulfilled(_connection: Connection, { connectionKit, returnFacet, saveICQConnection }: {
+                connectionKit: ConnectionKit;
+                returnFacet: string;
+                saveICQConnection?: `connection-${number}` | undefined;
+            }): any;
         };
         public: {
             /**
@@ -49,12 +92,51 @@ export type ICQConnectionStore = import("@endo/pass-style").RemotableObject & im
         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>[]>;
     };
+    parseQueryPacketWatcher: {
+        onFulfilled(ack: string): import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").ResponseQuery>[];
+    };
     connectionHandler: {
-        onOpen(connection: Remote<import("@agoric/network").Connection>, localAddr: `/ibc-port/${string}`, remoteAddr: `/${string}ibc-port/${string}/ordered/${string}` | `/${string}ibc-port/${string}/unordered/${string}`): Promise<void>;
+        onOpen(connection: Remote<Connection>, localAddr: `/ibc-port/${string}`, remoteAddr: `/${string}ibc-port/${string}/ordered/${string}` | `/${string}ibc-port/${string}/unordered/${string}`): Promise<void>;
         onClose(_connection: any, reason: any): Promise<void>;
         onReceive(connection: any, bytes: any): Promise<string>;
     };
 }>>;
+export type ConnectionKit = import("@endo/exo").GuardedKit<{
+    connection: {
+        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>[]>;
+    };
+    parseQueryPacketWatcher: {
+        onFulfilled(ack: string): import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").ResponseQuery>[];
+    };
+    connectionHandler: {
+        onOpen(connection: Remote<Connection>, localAddr: `/ibc-port/${string}`, remoteAddr: `/${string}ibc-port/${string}/ordered/${string}` | `/${string}ibc-port/${string}/unordered/${string}`): Promise<void>;
+        onClose(_connection: any, reason: any): Promise<void>;
+        onReceive(connection: any, bytes: any): Promise<string>;
+    };
+}> | import("@endo/exo").GuardedKit<{
+    parseTxPacketWatcher: {
+        onFulfilled(ack: string): string;
+    };
+    account: {
+        getAddress(): import("./orchestration-api.js").ChainAddress;
+        getBalance(_denom: any): never;
+        getBalances(): never;
+        getLocalAddress(): `/ibc-port/${string}`;
+        getRemoteAddress(): `/${string}ibc-port/${string}/ordered/${string}` | `/${string}ibc-port/${string}/unordered/${string}`;
+        getPort(): Port;
+        executeTx(): never;
+        executeEncodedTx(msgs: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/google/protobuf/any.js").Any>[], opts?: Omit<import("@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js").TxBody, "messages"> | undefined): Promise<string>;
+        close(): Promise<void>;
+        getPurse(brand: Brand): Promise<never>;
+    };
+    connectionHandler: {
+        onOpen(connection: Remote<Connection>, localAddr: `/ibc-port/${string}`, remoteAddr: `/${string}ibc-port/${string}/ordered/${string}` | `/${string}ibc-port/${string}/unordered/${string}`): Promise<void>;
+        onClose(_connection: any, reason: any): Promise<void>;
+        onReceive(connection: any, bytes: any): Promise<string>;
+    };
+}>;
 export type OrchestrationState = {
     powers: PowerStore;
     icqConnections: ICQConnectionStore;
@@ -64,6 +146,7 @@ export type OrchestrationKit = ReturnType<OrchestrationTools["makeOrchestrationK
 export type OrchestrationService = OrchestrationKit["public"];
 import type { Zone } from '@agoric/base-zone';
 import type { Port } from '@agoric/network';
+import type { Connection } from '@agoric/network';
 import type { IcaAccount } from './types.js';
 import type { Remote } from '@agoric/internal';
 //# sourceMappingURL=service.d.ts.map

package/src/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["service.js"],"names":[],"mappings":"AAoDA;;;GAOG;AAgHI;;;;;;;YA7DC;;;;;;eAMG;iCALQ,MAAM;YA2BjB;;;eAGG;;;;;;;;EAwCV;;;;;;;;;;;;;;yBArJY,QAAQ,CACpB,MAAU,mBAAmB,EAC7B,mBAAuB,CAAC,MAAM,mBAAmB,CAAC,CAC/C;;;;;;;;;;;;;iCA0BU;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,cAAc,EAAE,kBAAkB,CAAA;CAAE;iCA2H1D,UAAU,CAAC,OAAO,yBAAyB,CAAC;+BAC5C,UAAU,CAAC,kBAAkB,CAAC,sBAAsB,CAAC,CAAC;mCACtD,gBAAgB,CAAC,QAAQ,CAAC;0BA7KjB,mBAAmB;0BAEJ,iBAAiB;gCAEO,YAAY;4BAHjD,kBAAkB"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["service.js"],"names":[],"mappings":"AAuPO;wFAzOkB,CAAC;;;oBAYzB,SAAS;;;;YA2FF;;;;;;eAMG;;yBAHW,MAAM;;;;;YAkBpB;;;;;;eAMG;;;;;;QAeL;;;;WAIG;;YAED;;;;;;;eAOG;;+BAJiB,aAAa;6BACf,MAAM;;;;;YAoBxB;;;;;;eAMG;iCALQ,MAAM;YAuBjB;;;eAGG;;;;;;;;EA0CV;;;;;;;;;;;;;;yBAhOY,QAAQ,CACpB,MAAU,mBAAmB,EAC7B,mBAAuB,CAAC,MAAM,mBAAmB,CAAC,CAC/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAkIU,KAAK;;;;;;;;iCAjHL;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,cAAc,EAAE,kBAAkB,CAAA;CAAE;iCA+M1D,UAAU,CAAC,OAAO,yBAAyB,CAAC;+BAC5C,UAAU,CAAC,kBAAkB,CAAC,sBAAsB,CAAC,CAAC;mCACtD,gBAAgB,CAAC,QAAQ,CAAC;0BA1PjB,mBAAmB;0BAEQ,iBAAiB;gCAAjB,iBAAiB;gCAIY,YAAY;4BALlE,kBAAkB"}

package/src/service.js

@@ -1,6 +1,6 @@
 /** @file Orchestration service */
 
-import { V as E } from '@agoric/vow/vat.js';
+import { E } from '@endo/far';
 import { M } from '@endo/patterns';
 import { Shape as NetworkShape } from '@agoric/network';
 import { prepareChainAccountKit } from './exos/chain-account-kit.js';
@@ -13,9 +13,11 @@ import {
 /**
  * @import {Zone} from '@agoric/base-zone';
  * @import {Remote} from '@agoric/internal';
- * @import {Port, PortAllocator} from '@agoric/network';
+ * @import {Connection, Port, PortAllocator} from '@agoric/network';
  * @import {IBCConnectionID} from '@agoric/vats';
- * @import {ICQConnection, IcaAccount, ICQConnectionKit} from './types.js';
+ * @import {RemoteIbcAddress} from '@agoric/vats/tools/ibc-utils.js';
+ * @import {VowTools} from '@agoric/vow';
+ * @import {ICQConnection, IcaAccount, ICQConnectionKit, ChainAccountKit} from './types.js';
  */
 
 const { Fail, bare } = assert;
@@ -36,9 +38,9 @@ const { Fail, bare } = assert;
  * >} PowerStore
  */
 
-/**
- * @typedef {MapStore<IBCConnectionID, ICQConnectionKit>} ICQConnectionStore
- */
+/** @typedef {MapStore<IBCConnectionID, ICQConnectionKit>} ICQConnectionStore */
+
+/** @typedef {ChainAccountKit | ICQConnectionKit} ConnectionKit */
 
 /**
  * @template {keyof OrchestrationPowers} K
@@ -50,39 +52,54 @@ const getPower = (powers, name) => {
   return /** @type {OrchestrationPowers[K]} */ (powers.get(name));
 };
 
-export const OrchestrationI = M.interface('Orchestration', {
-  makeAccount: M.callWhen(M.string(), M.string(), M.string()).returns(
-    M.remotable('ChainAccount'),
-  ),
-  provideICQConnection: M.callWhen(M.string()).returns(
-    M.remotable('Connection'),
-  ),
-});
-
 /** @typedef {{ powers: PowerStore; icqConnections: ICQConnectionStore }} OrchestrationState */
 
 /**
  * @param {Zone} zone
+ * @param {VowTools} vowTools
  * @param {ReturnType<typeof prepareChainAccountKit>} makeChainAccountKit
  * @param {ReturnType<typeof prepareICQConnectionKit>} makeICQConnectionKit
  */
 const prepareOrchestrationKit = (
   zone,
+  { when, watch },
   makeChainAccountKit,
   makeICQConnectionKit,
 ) =>
   zone.exoClassKit(
     'Orchestration',
     {
-      self: M.interface('OrchestrationSelf', {
-        allocateICAControllerPort: M.callWhen().returns(
-          NetworkShape.Vow$(NetworkShape.Port),
+      requestICAChannelWatcher: M.interface('RequestICAChannelWatcher', {
+        onFulfilled: M.call(M.remotable('Port'))
+          .optional({ chainId: M.string(), remoteConnAddr: M.string() })
+          .returns(NetworkShape.Vow$(NetworkShape.Connection)),
+      }),
+      requestICQChannelWatcher: M.interface('RequestICQChannelWatcher', {
+        onFulfilled: M.call(M.remotable('Port'))
+          .optional({
+            remoteConnAddr: M.string(),
+            controllerConnectionId: M.string(),
+          })
+          .returns(NetworkShape.Vow$(NetworkShape.Connection)),
+      }),
+      channelOpenWatcher: M.interface('ChannelOpenWatcher', {
+        onFulfilled: M.call(M.remotable('Connection'))
+          .optional(
+            M.splitRecord(
+              { connectionKit: M.record(), returnFacet: M.string() },
+              { saveICQConnection: M.string() },
+            ),
+          )
+          .returns(M.remotable('ConnectionKit Holder facet')),
+      }),
+      public: M.interface('OrchestrationService', {
+        makeAccount: M.callWhen(M.string(), M.string(), M.string()).returns(
+          M.remotable('ChainAccountKit'),
         ),
-        allocateICQControllerPort: M.callWhen().returns(
-          NetworkShape.Vow$(NetworkShape.Port),
+        provideICQConnection: M.callWhen(M.string()).returns(
+          M.remotable('ICQConnection'),
         ),
       }),
-      public: OrchestrationI,
     },
     /** @param {Partial<OrchestrationPowers>} [initialPowers] */
     initialPowers => {
@@ -97,16 +114,78 @@ const prepareOrchestrationKit = (
       return /** @type {OrchestrationState} */ ({ powers, icqConnections });
     },
     {
-      self: {
-        async allocateICAControllerPort() {
-          const portAllocator = getPower(this.state.powers, 'portAllocator');
-          return E(portAllocator).allocateICAControllerPort();
+      requestICAChannelWatcher: {
+        /**
+         * @param {Port} port
+         * @param {{
+         *   chainId: string;
+         *   remoteConnAddr: RemoteIbcAddress;
+         * }} watchContext
+         */
+        onFulfilled(port, { chainId, remoteConnAddr }) {
+          const chainAccountKit = makeChainAccountKit(
+            chainId,
+            port,
+            remoteConnAddr,
+          );
+          return watch(
+            E(port).connect(remoteConnAddr, chainAccountKit.connectionHandler),
+            this.facets.channelOpenWatcher,
+            { returnFacet: 'account', connectionKit: chainAccountKit },
+          );
         },
-        async allocateICQControllerPort() {
-          const portAllocator = getPower(this.state.powers, 'portAllocator');
-          return E(portAllocator).allocateICAControllerPort();
+      },
+      requestICQChannelWatcher: {
+        /**
+         * @param {Port} port
+         * @param {{
+         *   remoteConnAddr: RemoteIbcAddress;
+         *   controllerConnectionId: IBCConnectionID;
+         * }} watchContext
+         */
+        onFulfilled(port, { remoteConnAddr, controllerConnectionId }) {
+          const connectionKit = makeICQConnectionKit(port);
+          /** @param {ICQConnectionKit} kit */
+          return watch(
+            E(port).connect(remoteConnAddr, connectionKit.connectionHandler),
+            this.facets.channelOpenWatcher,
+            {
+              connectionKit,
+              returnFacet: 'connection',
+              saveICQConnection: controllerConnectionId,
+            },
+          );
         },
       },
+      /**
+       * Waits for a channel (ICA, ICQ) to open and returns the consumer-facing
+       * facet of the ConnectionKit, specified by `returnFacet`. Saves the
+       * ConnectionKit if `saveICQConnection` is provided.
+       */
+      channelOpenWatcher: {
+        /**
+         * @param {Connection} _connection
+         * @param {{
+         *   connectionKit: ConnectionKit;
+         *   returnFacet: string;
+         *   saveICQConnection?: IBCConnectionID;
+         * }} watchContext
+         */
+        onFulfilled(
+          _connection,
+          { connectionKit, returnFacet, saveICQConnection },
+        ) {
+          if (saveICQConnection) {
+            this.state.icqConnections.init(
+              saveICQConnection,
+              /** @type {ICQConnectionKit} */ (connectionKit),
+            );
+          }
+          return connectionKit[returnFacet];
+        },
+        // TODO #9317 if we fail, should we revoke the port (if it was created in this flow)?
+        // onRejected() {}
+      },
       public: {
         /**
          * @param {string} chainId
@@ -115,65 +194,63 @@ const prepareOrchestrationKit = (
          * @param {IBCConnectionID} controllerConnectionId self connection_id
          * @returns {Promise<IcaAccount>}
          */
-        async makeAccount(chainId, hostConnectionId, controllerConnectionId) {
-          const port = await this.facets.self.allocateICAControllerPort();
-
+        makeAccount(chainId, hostConnectionId, controllerConnectionId) {
           const remoteConnAddr = makeICAChannelAddress(
             hostConnectionId,
             controllerConnectionId,
           );
-          const chainAccountKit = makeChainAccountKit(
-            chainId,
-            port,
-            remoteConnAddr,
-          );
-
-          // await so we do not return a ChainAccount before it successfully instantiates
-          await E(port).connect(
-            remoteConnAddr,
-            chainAccountKit.connectionHandler,
+          const portAllocator = getPower(this.state.powers, 'portAllocator');
+          return when(
+            watch(
+              E(portAllocator).allocateICAControllerPort(),
+              this.facets.requestICAChannelWatcher,
+              {
+                chainId,
+                remoteConnAddr,
+              },
+            ),
           );
-          // FIXME if we fail, should we close the port (if it was created in this flow)?
-          return chainAccountKit.account;
         },
         /**
          * @param {IBCConnectionID} controllerConnectionId
          * @returns {Promise<ICQConnection>}
          */
-        async provideICQConnection(controllerConnectionId) {
+        provideICQConnection(controllerConnectionId) {
           if (this.state.icqConnections.has(controllerConnectionId)) {
-            return this.state.icqConnections.get(controllerConnectionId)
-              .connection;
+            // TODO #9281 do not return synchronously. see https://github.com/Agoric/agoric-sdk/pull/9454#discussion_r1626898694
+            return when(
+              this.state.icqConnections.get(controllerConnectionId).connection,
+            );
           }
-          // allocate a new Port for every Connection
-          // TODO #9317 optimize ICQ port allocation
-          const port = await this.facets.self.allocateICQControllerPort();
           const remoteConnAddr = makeICQChannelAddress(controllerConnectionId);
-          const icqConnectionKit = makeICQConnectionKit(port);
-
-          // await so we do not return/save a ICQConnection before it successfully instantiates
-          await E(port).connect(
-            remoteConnAddr,
-            icqConnectionKit.connectionHandler,
-          );
-
-          this.state.icqConnections.init(
-            controllerConnectionId,
-            icqConnectionKit,
+          const portAllocator = getPower(this.state.powers, 'portAllocator');
+          return when(
+            watch(
+              // allocate a new Port for every Connection
+              // TODO #9317 optimize ICQ port allocation
+              E(portAllocator).allocateICQControllerPort(),
+              this.facets.requestICQChannelWatcher,
+              {
+                remoteConnAddr,
+                controllerConnectionId,
+              },
+            ),
           );
-
-          return icqConnectionKit.connection;
         },
       },
     },
   );
 
-/** @param {Zone} zone */
-export const prepareOrchestrationTools = zone => {
-  const makeChainAccountKit = prepareChainAccountKit(zone);
-  const makeICQConnectionKit = prepareICQConnectionKit(zone);
+/**
+ * @param {Zone} zone
+ * @param {VowTools} vowTools
+ */
+export const prepareOrchestrationTools = (zone, vowTools) => {
+  const makeChainAccountKit = prepareChainAccountKit(zone, vowTools);
+  const makeICQConnectionKit = prepareICQConnectionKit(zone, vowTools);
   const makeOrchestrationKit = prepareOrchestrationKit(
     zone,
+    vowTools,
     makeChainAccountKit,
     makeICQConnectionKit,
   );