@agoric/orchestration 0.1.1-calypso-dev-84eb287.0

package/src/proposals/start-stakeOsmo.js

@@ -0,0 +1,106 @@
+import { makeTracer } from '@agoric/internal';
+import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
+import { heapVowE as E } from '@agoric/vow/vat.js';
+import { makeChainHub } from '../exos/chain-hub.js';
+
+/**
+ * @import {IBCConnectionID} from '@agoric/vats';
+ * @import {StakeIcaSF} from '../examples/stakeIca.contract';
+ */
+
+const trace = makeTracer('StartStakeOsmo', true);
+
+/**
+ * @param {BootstrapPowers & {
+ *   installation: {
+ *     consume: {
+ *       stakeIca: Installation<
+ *         import('../examples/stakeIca.contract.js').start
+ *       >;
+ *     };
+ *   };
+ * }} powers
+ */
+export const startStakeOsmo = async ({
+  consume: {
+    agoricNames,
+    board,
+    chainStorage,
+    chainTimerService,
+    orchestration,
+    startUpgradable,
+  },
+  installation: {
+    consume: { stakeIca },
+  },
+  instance: {
+    // @ts-expect-error stakeOsmo not typed
+    produce: { stakeOsmo: produceInstance },
+  },
+}) => {
+  const VSTORAGE_PATH = 'stakeOsmo';
+  trace('startStakeOsmo');
+  await null;
+
+  const storageNode = await makeStorageNodeChild(chainStorage, VSTORAGE_PATH);
+  const marshaller = await E(board).getPublishingMarshaller();
+
+  const chainHub = makeChainHub(await agoricNames);
+
+  const [_, osmosis, connectionInfo] = await E.when(
+    chainHub.getChainsAndConnection('agoric', 'osmosis'),
+  );
+
+  /** @type {StartUpgradableOpts<StakeIcaSF>} */
+  const startOpts = {
+    label: 'stakeOsmo',
+    installation: stakeIca,
+    terms: {
+      chainId: osmosis.chainId,
+      hostConnectionId: connectionInfo.id,
+      controllerConnectionId: connectionInfo.counterparty.connection_id,
+      bondDenom: osmosis.stakingTokens[0].denom,
+      icqEnabled: osmosis.icqEnabled,
+    },
+    privateArgs: {
+      orchestration: await orchestration,
+      storageNode,
+      marshaller,
+      timer: await chainTimerService,
+    },
+  };
+
+  const { instance } = await E(startUpgradable)(startOpts);
+  produceInstance.resolve(instance);
+};
+harden(startStakeOsmo);
+
+export const getManifestForStakeOsmo = (
+  { restoreRef },
+  { installKeys, ...options },
+) => {
+  return {
+    manifest: {
+      [startStakeOsmo.name]: {
+        consume: {
+          agoricNames: true,
+          board: true,
+          chainStorage: true,
+          chainTimerService: true,
+          orchestration: true,
+          startUpgradable: true,
+        },
+        installation: {
+          consume: { stakeIca: true },
+        },
+        instance: {
+          produce: { stakeOsmo: true },
+        },
+      },
+    },
+    installations: {
+      stakeIca: restoreRef(installKeys.stakeIca),
+    },
+    options,
+  };
+};

package/src/service.d.ts

@@ -0,0 +1,97 @@
+export function prepareOrchestrationTools(zone: Zone, vowTools: VowTools): {
+    makeOrchestrationKit: (initialPowers?: Partial<OrchestrationPowers> | undefined) => import("@endo/exo").GuardedKit<{
+        requestICAChannelWatcher: {
+            /**
+             * @param {Port} port
+             * @param {{
+             *   chainId: string;
+             *   remoteConnAddr: RemoteIbcAddress;
+             * }} watchContext
+             */
+            onFulfilled(port: Port, { chainId, remoteConnAddr }: {
+                chainId: string;
+                remoteConnAddr: RemoteIbcAddress;
+            }): Vow<any>;
+        };
+        requestICQChannelWatcher: {
+            /**
+             * @param {Port} port
+             * @param {{
+             *   remoteConnAddr: RemoteIbcAddress;
+             *   controllerConnectionId: IBCConnectionID;
+             * }} watchContext
+             */
+            onFulfilled(port: Port, { remoteConnAddr, controllerConnectionId }: {
+                remoteConnAddr: RemoteIbcAddress;
+                controllerConnectionId: IBCConnectionID;
+            }): 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?: IBCConnectionID;
+            }): any;
+        };
+        public: {
+            /**
+             * @param {string} chainId
+             * @param {IBCConnectionID} hostConnectionId the counterparty
+             *   connection_id
+             * @param {IBCConnectionID} controllerConnectionId self connection_id
+             * @returns {Vow<IcaAccount>}
+             */
+            makeAccount(chainId: string, hostConnectionId: IBCConnectionID, controllerConnectionId: IBCConnectionID): Vow<IcaAccount>;
+            /**
+             * @param {IBCConnectionID} controllerConnectionId
+             * @returns {Vow<ICQConnection> | ICQConnection}
+             */
+            provideICQConnection(controllerConnectionId: IBCConnectionID): Vow<ICQConnection> | ICQConnection;
+        };
+    }>;
+};
+export type OrchestrationPowers = {
+    portAllocator: Remote<PortAllocator>;
+};
+/**
+ * PowerStore is used so additional powers can be added on upgrade. See
+ * [#7337](https://github.com/Agoric/agoric-sdk/issues/7337) for tracking on Exo
+ * state migrations.
+ */
+export type PowerStore = MapStore<keyof OrchestrationPowers, OrchestrationPowers[keyof OrchestrationPowers]>;
+export type ICQConnectionStore = MapStore<IBCConnectionID, ICQConnectionKit>;
+export type ConnectionKit = ChainAccountKit | ICQConnectionKit;
+export type OrchestrationState = {
+    powers: PowerStore;
+    icqConnections: ICQConnectionStore;
+};
+export type OrchestrationTools = ReturnType<typeof prepareOrchestrationTools>;
+export type OrchestrationKit = ReturnType<OrchestrationTools["makeOrchestrationKit"]>;
+export type OrchestrationService = OrchestrationKit["public"];
+import type { Zone } from '@agoric/base-zone';
+import type { VowTools } from '@agoric/vow';
+import type { Port } from '@agoric/network';
+import type { RemoteIbcAddress } from '@agoric/vats/tools/ibc-utils.js';
+import type { Vow } from '@agoric/vow';
+import type { IBCConnectionID } from '@agoric/vats';
+import type { Connection } from '@agoric/network';
+import type { IcaAccount } from './types.js';
+import type { ICQConnection } from './types.js';
+import type { PortAllocator } from '@agoric/network';
+import type { Remote } from '@agoric/internal';
+import type { ICQConnectionKit } from './types.js';
+import type { ChainAccountKit } from './types.js';
+//# sourceMappingURL=service.d.ts.map

package/src/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["service.js"],"names":[],"mappings":"AAkPO,gDAHI,IAAI,YACJ,QAAQ;;;YA3HX;;;;;;eAMG;8BALQ,IAAI,+BACJ;gBACV,OAAW,EAAE,MAAM,CAAC;gBACpB,cAAkB,EAAE,gBAAgB,CAAC;aAClC;;;YAgBJ;;;;;;eAMG;8BALQ,IAAI,8CACJ;gBACV,cAAkB,EAAE,gBAAgB,CAAC;gBACrC,sBAA0B,EAAE,eAAe,CAAC;aACzC;;QAgBN;;;;WAIG;;YAED;;;;;;;eAOG;qCANQ,UAAU,qDACV;gBACV,aAAiB,EAAE,aAAa,CAAC;gBACjC,WAAe,EAAE,MAAM,CAAC;gBACxB,iBAAqB,CAAC,EAAE,eAAe,CAAC;aACrC;;;YAkBJ;;;;;;eAMG;iCALQ,MAAM,oBACN,eAAe,0BAEf,eAAe,GACb,IAAI,UAAU,CAAC;YAiB5B;;;eAGG;yDAFQ,eAAe,GACb,IAAI,aAAa,CAAC,GAAG,aAAa;;;EAwCtD;;mBAnOa,OAAO,aAAa,CAAC;;;;;;;yBAQtB,QAAQ,CACpB,MAAU,mBAAmB,EAC7B,mBAAuB,CAAC,MAAM,mBAAmB,CAAC,CAC/C;iCAGU,QAAQ,CAAC,eAAe,EAAE,gBAAgB,CAAC;4BAE3C,eAAe,GAAG,gBAAgB;iCAYlC;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,cAAc,EAAE,kBAAkB,CAAA;CAAE;iCA0M1D,UAAU,CAAC,OAAO,yBAAyB,CAAC;+BAC5C,UAAU,CAAC,kBAAkB,CAAC,sBAAsB,CAAC,CAAC;mCACtD,gBAAgB,CAAC,QAAQ,CAAC;0BArPjB,mBAAmB;8BAKV,aAAa;0BAHK,iBAAiB;sCAEhC,iCAAiC;yBACpC,aAAa;qCAFX,cAAc;gCADE,iBAAiB;gCAIY,YAAY;mCAAZ,YAAY;mCAJzC,iBAAiB;4BAD1C,kBAAkB;sCAKoC,YAAY;qCAAZ,YAAY"}

package/src/service.js

@@ -0,0 +1,259 @@
+/** @file Orchestration service */
+
+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';
+import { prepareICQConnectionKit } from './exos/icq-connection-kit.js';
+import {
+  makeICAChannelAddress,
+  makeICQChannelAddress,
+} from './utils/address.js';
+
+/**
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {Remote} from '@agoric/internal';
+ * @import {Connection, Port, PortAllocator} from '@agoric/network';
+ * @import {IBCConnectionID} from '@agoric/vats';
+ * @import {RemoteIbcAddress} from '@agoric/vats/tools/ibc-utils.js';
+ * @import {Vow, VowTools} from '@agoric/vow';
+ * @import {ICQConnection, IcaAccount, ICQConnectionKit, ChainAccountKit} from './types.js';
+ */
+
+const { Fail, bare } = assert;
+const { Vow$ } = NetworkShape; // TODO #9611
+/**
+ * @typedef {object} OrchestrationPowers
+ * @property {Remote<PortAllocator>} portAllocator
+ */
+
+/**
+ * PowerStore is used so additional powers can be added on upgrade. See
+ * [#7337](https://github.com/Agoric/agoric-sdk/issues/7337) for tracking on Exo
+ * state migrations.
+ *
+ * @typedef {MapStore<
+ *   keyof OrchestrationPowers,
+ *   OrchestrationPowers[keyof OrchestrationPowers]
+ * >} PowerStore
+ */
+
+/** @typedef {MapStore<IBCConnectionID, ICQConnectionKit>} ICQConnectionStore */
+
+/** @typedef {ChainAccountKit | ICQConnectionKit} ConnectionKit */
+
+/**
+ * @template {keyof OrchestrationPowers} K
+ * @param {PowerStore} powers
+ * @param {K} name
+ */
+const getPower = (powers, name) => {
+  powers.has(name) || Fail`need powers.${bare(name)} for this method`;
+  return /** @type {OrchestrationPowers[K]} */ (powers.get(name));
+};
+
+/** @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,
+  { watch },
+  makeChainAccountKit,
+  makeICQConnectionKit,
+) =>
+  zone.exoClassKit(
+    'Orchestration',
+    {
+      requestICAChannelWatcher: M.interface('RequestICAChannelWatcher', {
+        onFulfilled: M.call(M.remotable('Port'))
+          .optional({ chainId: M.string(), remoteConnAddr: M.string() })
+          .returns(Vow$(NetworkShape.Connection)),
+      }),
+      requestICQChannelWatcher: M.interface('RequestICQChannelWatcher', {
+        onFulfilled: M.call(M.remotable('Port'))
+          .optional({
+            remoteConnAddr: M.string(),
+            controllerConnectionId: M.string(),
+          })
+          .returns(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.call(M.string(), M.string(), M.string()).returns(
+          Vow$(M.remotable('ChainAccountKit')),
+        ),
+        provideICQConnection: M.call(M.string()).returns(
+          Vow$(M.remotable('ICQConnection')),
+        ),
+      }),
+    },
+    /** @param {Partial<OrchestrationPowers>} [initialPowers] */
+    initialPowers => {
+      /** @type {PowerStore} */
+      const powers = zone.detached().mapStore('PowerStore');
+      if (initialPowers) {
+        for (const [name, power] of Object.entries(initialPowers)) {
+          powers.init(/** @type {keyof OrchestrationPowers} */ (name), power);
+        }
+      }
+      const icqConnections = zone.detached().mapStore('ICQConnections');
+      return /** @type {OrchestrationState} */ ({ powers, icqConnections });
+    },
+    {
+      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 },
+          );
+        },
+      },
+      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
+         * @param {IBCConnectionID} hostConnectionId the counterparty
+         *   connection_id
+         * @param {IBCConnectionID} controllerConnectionId self connection_id
+         * @returns {Vow<IcaAccount>}
+         */
+        makeAccount(chainId, hostConnectionId, controllerConnectionId) {
+          const remoteConnAddr = makeICAChannelAddress(
+            hostConnectionId,
+            controllerConnectionId,
+          );
+          const portAllocator = getPower(this.state.powers, 'portAllocator');
+          return watch(
+            E(portAllocator).allocateICAControllerPort(),
+            this.facets.requestICAChannelWatcher,
+            {
+              chainId,
+              remoteConnAddr,
+            },
+          );
+        },
+        /**
+         * @param {IBCConnectionID} controllerConnectionId
+         * @returns {Vow<ICQConnection> | ICQConnection}
+         */
+        provideICQConnection(controllerConnectionId) {
+          if (this.state.icqConnections.has(controllerConnectionId)) {
+            // TODO #9281 do not return synchronously. see https://github.com/Agoric/agoric-sdk/pull/9454#discussion_r1626898694
+            return this.state.icqConnections.get(controllerConnectionId)
+              .connection;
+          }
+          const remoteConnAddr = makeICQChannelAddress(controllerConnectionId);
+          const portAllocator = getPower(this.state.powers, 'portAllocator');
+          return watch(
+            // allocate a new Port for every Connection
+            // TODO #9317 optimize ICQ port allocation
+            E(portAllocator).allocateICQControllerPort(),
+            this.facets.requestICQChannelWatcher,
+            {
+              remoteConnAddr,
+              controllerConnectionId,
+            },
+          );
+        },
+      },
+    },
+  );
+
+/**
+ * @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,
+  );
+
+  return harden({ makeOrchestrationKit });
+};
+harden(prepareOrchestrationTools);
+
+/** @typedef {ReturnType<typeof prepareOrchestrationTools>} OrchestrationTools */
+/** @typedef {ReturnType<OrchestrationTools['makeOrchestrationKit']>} OrchestrationKit */
+/** @typedef {OrchestrationKit['public']} OrchestrationService */

package/src/typeGuards.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Used for IBC Channel Connections that only send outgoing transactions. If
+ * your channel expects incoming transactions, please extend this interface to
+ * include the `onReceive` handler.
+ */
+export const OutboundConnectionHandlerI: import("@endo/patterns").InterfaceGuard<{
+    onOpen: import("@endo/patterns").MethodGuard;
+    onClose: import("@endo/patterns").MethodGuard;
+}>;
+export namespace ChainAddressShape {
+    let address: import("@endo/patterns").Matcher;
+    let chainId: import("@endo/patterns").Matcher;
+    let addressEncoding: import("@endo/patterns").Matcher;
+}
+export namespace Proto3Shape {
+    let typeUrl: import("@endo/patterns").Matcher;
+    let value: import("@endo/patterns").Matcher;
+}
+export namespace CoinShape {
+    let value_1: import("@endo/patterns").Matcher;
+    export { value_1 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_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;
+}
+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;
+export const CosmosChainInfoShape: import("@endo/patterns").Matcher;
+export const ChainInfoShape: import("@endo/patterns").Matcher;
+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_3: import("@endo/patterns").Matcher;
+    export { value_3 as value };
+}
+/** @see {Chain} */
+export const ChainFacadeI: import("@endo/patterns").InterfaceGuard<{
+    getChainInfo: import("@endo/patterns").MethodGuard;
+    makeAccount: import("@endo/patterns").MethodGuard;
+}>;
+//# sourceMappingURL=typeGuards.d.ts.map

package/src/typeGuards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH;;;GAQE;;;;;;;;;;;;;;;;;;;;;AAiBF,8DAAkE;;;;;AAOlE,uEAUE;AAEF,iEAA4C;AAC5C,mEAQG;AACH,oEAA+C;AAC/C,sEAYG;AAEH,oEAUE;AAGF,8DAAsC;AACtC,sEAAuE;AACvE,0DAAqC;AAErC,8DAAsC;;;;;;AAItC,mBAAmB;AACnB;;;GAGG"}

package/src/typeGuards.js

@@ -0,0 +1,104 @@
+import { AmountShape } from '@agoric/ertp';
+import { VowShape } from '@agoric/vow';
+import { M } from '@endo/patterns';
+
+/**
+ * Used for IBC Channel Connections that only send outgoing transactions. If
+ * your channel expects incoming transactions, please extend this interface to
+ * include the `onReceive` handler.
+ */
+export const OutboundConnectionHandlerI = M.interface(
+  'OutboundConnectionHandler',
+  {
+    onOpen: M.callWhen(M.any(), M.string(), M.string(), M.any()).returns(
+      M.any(),
+    ),
+    onClose: M.callWhen(M.any(), M.any(), M.any()).returns(M.any()),
+  },
+);
+
+export const ChainAddressShape = {
+  address: M.string(),
+  chainId: M.string(),
+  addressEncoding: M.string(),
+};
+
+export const Proto3Shape = {
+  typeUrl: M.string(),
+  value: M.string(),
+};
+
+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);
+
+export const DelegationShape = harden({
+  validatorAddress: M.string(),
+  shares: M.string(), // TODO: bigint?
+});
+
+export const IBCTransferOptionsShape = M.splitRecord(
+  {},
+  {
+    timeoutTimestamp: M.bigint(),
+    timeoutHeight: {
+      revisionHeight: M.bigint(),
+      revisionNumber: M.bigint(),
+    },
+    memo: M.string(),
+  },
+);
+
+export const IBCChannelIDShape = M.string();
+export const IBCChannelInfoShape = M.splitRecord({
+  portId: M.string(),
+  channelId: IBCChannelIDShape,
+  counterPartyPortId: M.string(),
+  counterPartyChannelId: IBCChannelIDShape,
+  ordering: M.scalar(), // XXX
+  state: M.scalar(), // XXX
+  version: M.string(),
+});
+export const IBCConnectionIDShape = M.string();
+export const IBCConnectionInfoShape = M.splitRecord({
+  id: IBCConnectionIDShape,
+  client_id: M.string(),
+  state: M.scalar(), // XXX STATE_OPEN or...
+  counterparty: {
+    client_id: M.string(),
+    connection_id: IBCConnectionIDShape,
+    prefix: {
+      key_prefix: M.string(),
+    },
+  },
+  transferChannel: IBCChannelInfoShape,
+});
+
+export const CosmosChainInfoShape = M.splitRecord(
+  {
+    chainId: M.string(),
+  },
+  {
+    connections: M.record(),
+    stakingTokens: M.arrayOf({ denom: M.string() }),
+    // UNTIL https://github.com/Agoric/agoric-sdk/issues/9326
+    icqEnabled: M.boolean(),
+  },
+);
+
+// FIXME more validation
+export const ChainInfoShape = M.any();
+export const LocalChainAccountShape = M.remotable('LocalChainAccount');
+export const DenomShape = M.string();
+// FIXME more validation
+export const BrandInfoShape = M.any();
+
+export const DenomAmountShape = { denom: DenomShape, value: M.bigint() };
+
+/** @see {Chain} */
+export const ChainFacadeI = M.interface('ChainFacade', {
+  getChainInfo: M.call().returns(VowShape),
+  makeAccount: M.call().returns(VowShape),
+});

package/src/types.d.ts

@@ -0,0 +1,11 @@
+/** @file Rollup of all type definitions in the package, for local import and external export */
+export type * from './chain-info.js';
+export type * from './cosmos-api.js';
+export type * from './ethereum-api.js';
+export type * from './exos/chain-account-kit.js';
+export type * from './exos/icq-connection-kit.js';
+export type * from './internal.js';
+export type * from './orchestration-api.js';
+export type * from './service.js';
+export type * from './vat-orchestration.js';
+//# sourceMappingURL=types.d.ts.map

package/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":"AAAA,gGAAgG;AAEhG,mBAAmB,iBAAiB,CAAC;AACrC,mBAAmB,iBAAiB,CAAC;AACrC,mBAAmB,mBAAmB,CAAC;AACvC,mBAAmB,6BAA6B,CAAC;AACjD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,eAAe,CAAC;AACnC,mBAAmB,wBAAwB,CAAC;AAC5C,mBAAmB,cAAc,CAAC;AAClC,mBAAmB,wBAAwB,CAAC"}

package/src/types.ts

@@ -0,0 +1,11 @@
+/** @file Rollup of all type definitions in the package, for local import and external export */
+
+export type * from './chain-info.js';
+export type * from './cosmos-api.js';
+export type * from './ethereum-api.js';
+export type * from './exos/chain-account-kit.js';
+export type * from './exos/icq-connection-kit.js';
+export type * from './internal.js';
+export type * from './orchestration-api.js';
+export type * from './service.js';
+export type * from './vat-orchestration.js';

package/src/utils/address.d.ts

@@ -0,0 +1,14 @@
+export function makeICAChannelAddress(hostConnectionId: IBCConnectionID, controllerConnectionId: IBCConnectionID, { version, encoding, ordering, txType, }?: {
+    encoding?: string | undefined;
+    ordering?: "ordered" | "unordered" | undefined;
+    txType?: string | undefined;
+    version?: string | undefined;
+} | undefined): RemoteIbcAddress;
+export function makeICQChannelAddress(controllerConnectionId: IBCConnectionID, { version }?: {
+    version?: string;
+} | undefined): RemoteIbcAddress;
+export function findAddressField(remoteAddressString: RemoteIbcAddress): ChainAddress["address"] | undefined;
+import type { IBCConnectionID } from '@agoric/vats';
+import type { RemoteIbcAddress } from '@agoric/vats/tools/ibc-utils.js';
+import type { ChainAddress } from '../types.js';
+//# sourceMappingURL=address.d.ts.map

package/src/utils/address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["address.js"],"names":[],"mappings":"AAoBO,wDAXI,eAAe,0BACf,eAAe;;;;;gBAQb,gBAAgB,CAuB5B;AAQM,8DAJI,eAAe;cACH,MAAM;gBAChB,gBAAgB,CAQ5B;AAaM,sDAJI,gBAAgB,GAEd,YAAY,CAAC,SAAS,CAAC,GAAG,SAAS,CAW/C;qCA1EiC,cAAc;sCAEb,iCAAiC;kCADrC,aAAa"}