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

package/src/exos/chain-account-kit.js

@@ -0,0 +1,210 @@
+/** @file ChainAccount exo */
+import { NonNullish } from '@agoric/assert';
+import { makeTracer } from '@agoric/internal';
+import { VowShape } from '@agoric/vow';
+import { E } from '@endo/far';
+import { M } from '@endo/patterns';
+import {
+  ChainAddressShape,
+  OutboundConnectionHandlerI,
+  Proto3Shape,
+} from '../typeGuards.js';
+import { findAddressField } from '../utils/address.js';
+import { makeTxPacket, parseTxPacket } from '../utils/packet.js';
+
+/**
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {Connection, Port} from '@agoric/network';
+ * @import {Remote, Vow, VowTools} from '@agoric/vow';
+ * @import {AnyJson} from '@agoric/cosmic-proto';
+ * @import {TxBody} from '@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js';
+ * @import {LocalIbcAddress, RemoteIbcAddress} from '@agoric/vats/tools/ibc-utils.js';
+ * @import {ChainAddress} from '../types.js';
+ */
+
+const { Fail } = assert;
+const trace = makeTracer('ChainAccountKit');
+
+/** @typedef {'UNPARSABLE_CHAIN_ADDRESS'} UnparsableChainAddress */
+const UNPARSABLE_CHAIN_ADDRESS = 'UNPARSABLE_CHAIN_ADDRESS';
+
+export const ChainAccountI = M.interface('ChainAccount', {
+  getAddress: M.call().returns(ChainAddressShape),
+  getBalance: M.call(M.string()).returns(VowShape),
+  getBalances: M.call().returns(VowShape),
+  getLocalAddress: M.call().returns(M.string()),
+  getRemoteAddress: M.call().returns(M.string()),
+  getPort: M.call().returns(M.remotable('Port')),
+  executeTx: M.call(M.arrayOf(M.record())).returns(VowShape),
+  executeEncodedTx: M.call(M.arrayOf(Proto3Shape))
+    .optional(M.record())
+    .returns(VowShape),
+  close: M.call().returns(VowShape),
+  getPurse: M.call().returns(VowShape),
+});
+
+/**
+ * @typedef {{
+ *   chainId: string;
+ *   port: Port;
+ *   connection: Remote<Connection> | undefined;
+ *   localAddress: LocalIbcAddress | undefined;
+ *   requestedRemoteAddress: string;
+ *   remoteAddress: RemoteIbcAddress | undefined;
+ *   chainAddress: ChainAddress | undefined;
+ * }} State
+ */
+
+/**
+ * @param {Zone} zone
+ * @param {VowTools} vowTools
+ */
+export const prepareChainAccountKit = (zone, { watch, asVow }) =>
+  zone.exoClassKit(
+    'ChainAccountKit',
+    {
+      account: ChainAccountI,
+      connectionHandler: OutboundConnectionHandlerI,
+      parseTxPacketWatcher: M.interface('ParseTxPacketWatcher', {
+        onFulfilled: M.call(M.string())
+          .optional(M.arrayOf(M.undefined())) // does not need watcherContext
+          .returns(M.string()),
+      }),
+    },
+    /**
+     * @param {string} chainId
+     * @param {Port} port
+     * @param {string} requestedRemoteAddress
+     */
+    (chainId, port, requestedRemoteAddress) =>
+      /** @type {State} */ ({
+        chainId,
+        port,
+        connection: undefined,
+        requestedRemoteAddress,
+        remoteAddress: undefined,
+        chainAddress: undefined,
+        localAddress: undefined,
+      }),
+    {
+      parseTxPacketWatcher: {
+        /** @param {string} ack */
+        onFulfilled(ack) {
+          return parseTxPacket(ack);
+        },
+      },
+      account: {
+        /** @returns {ChainAddress} */
+        getAddress() {
+          return NonNullish(
+            this.state.chainAddress,
+            'ICA channel creation acknowledgement not yet received.',
+          );
+        },
+        getBalance(_denom) {
+          // TODO https://github.com/Agoric/agoric-sdk/issues/9610
+          // UNTIL https://github.com/Agoric/agoric-sdk/issues/9326
+          return asVow(() => Fail`not yet implemented`);
+        },
+        getBalances() {
+          // TODO https://github.com/Agoric/agoric-sdk/issues/9610
+          // UNTIL https://github.com/Agoric/agoric-sdk/issues/9326
+          return asVow(() => Fail`not yet implemented`);
+        },
+        getLocalAddress() {
+          return NonNullish(
+            this.state.localAddress,
+            'local address not available',
+          );
+        },
+        getRemoteAddress() {
+          return NonNullish(
+            this.state.remoteAddress,
+            'remote address not available',
+          );
+        },
+        getPort() {
+          return this.state.port;
+        },
+        executeTx() {
+          return asVow(() => Fail`not yet implemented`);
+        },
+        /**
+         * Submit a transaction on behalf of the remote account for execution on
+         * the remote chain.
+         *
+         * @param {AnyJson[]} msgs
+         * @param {Omit<TxBody, 'messages'>} [opts]
+         * @returns {Vow<string>} - base64 encoded bytes string. Can be decoded
+         *   using the corresponding `Msg*Response` object.
+         * @throws {Error} if packet fails to send or an error is returned
+         */
+        executeEncodedTx(msgs, opts) {
+          return asVow(() => {
+            const { connection } = this.state;
+            if (!connection) throw Fail`connection not available`;
+            return watch(
+              E(connection).send(makeTxPacket(msgs, opts)),
+              this.facets.parseTxPacketWatcher,
+            );
+          });
+        },
+        /**
+         * Close the remote account
+         *
+         * @returns {Vow<void>}
+         * @throws {Error} if connection is not available or already closed
+         */
+        close() {
+          return asVow(() => {
+            /// TODO #9192 what should the behavior be here? and `onClose`?
+            // - retrieve assets?
+            // - revoke the port?
+            const { connection } = this.state;
+            if (!connection) throw Fail`connection not available`;
+            return E(connection).close();
+          });
+        },
+        /**
+         * get Purse for a brand to .withdraw() a Payment from the account
+         *
+         * @param {Brand} brand
+         */
+        getPurse(brand) {
+          console.log('getPurse got', brand);
+          return asVow(() => Fail`not yet implemented`);
+        },
+      },
+      connectionHandler: {
+        /**
+         * @param {Remote<Connection>} connection
+         * @param {LocalIbcAddress} localAddr
+         * @param {RemoteIbcAddress} remoteAddr
+         */
+        async onOpen(connection, localAddr, remoteAddr) {
+          trace(`ICA Channel Opened for ${localAddr} at ${remoteAddr}`);
+          this.state.connection = connection;
+          this.state.remoteAddress = remoteAddr;
+          this.state.localAddress = localAddr;
+          this.state.chainAddress = harden({
+            // FIXME need a fallback value like icacontroller-1-connection-1 if this fails
+            // https://github.com/Agoric/agoric-sdk/issues/9066
+            address: findAddressField(remoteAddr) || UNPARSABLE_CHAIN_ADDRESS,
+            chainId: this.state.chainId,
+            addressEncoding: 'bech32',
+          });
+        },
+        /**
+         * @param {Remote<Connection>} _connection
+         * @param {unknown} reason
+         */
+        async onClose(_connection, reason) {
+          trace(`ICA Channel closed. Reason: ${reason}`);
+          // FIXME handle connection closing https://github.com/Agoric/agoric-sdk/issues/9192
+          // XXX is there a scenario where a connection will unexpectedly close? _I think yes_
+        },
+      },
+    },
+  );
+
+/** @typedef {ReturnType<ReturnType<typeof prepareChainAccountKit>>} ChainAccountKit */

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

@@ -0,0 +1,77 @@
+/**
+ * @import {NameHub} from '@agoric/vats';
+ * @import {Vow} from '@agoric/vow';
+ * @import {CosmosChainInfo, IBCConnectionInfo} from '../cosmos-api.js';
+ * @import {ChainInfo, KnownChains} from '../chain-info.js';
+ * @import {Remote} from '@agoric/internal';
+ * @import {Zone} from '@agoric/zone';
+ */
+/**
+ * @template {string} K
+ * @typedef {K extends keyof KnownChains
+ *   ? Omit<KnownChains[K], 'connections'>
+ *   : ChainInfo} ActualChainInfo
+ */
+/** agoricNames key for ChainInfo hub */
+export const CHAIN_KEY: "chain";
+/** namehub for connection info */
+export const CONNECTIONS_KEY: "chainConnection";
+export function connectionKey(chainId1: string, chainId2: string): string;
+export function makeChainHub(agoricNames: Remote<NameHub>, zone?: Zone | undefined): import("@endo/exo").Guarded<{
+    /**
+     * Register a new chain. The name will override a name in well known chain
+     * names.
+     *
+     * If a durable zone was not provided, registration will not survive a
+     * reincarnation of the vat. Then if the chain is not yet in the well known
+     * names at that point, it will have to be registered again. In an unchanged
+     * contract `start` the call will happen again naturally.
+     *
+     * @param {string} name
+     * @param {CosmosChainInfo} chainInfo
+     */
+    registerChain(name: string, chainInfo: CosmosChainInfo): void;
+    /**
+     * @template {string} K
+     * @param {K} chainName
+     * @returns {Vow<ActualChainInfo<K>>}
+     */
+    getChainInfo<K extends string>(chainName: K): Vow<ActualChainInfo<K>>;
+    /**
+     * @param {string} chainId1
+     * @param {string} chainId2
+     * @param {IBCConnectionInfo} connectionInfo
+     */
+    registerConnection(chainId1: string, chainId2: string, connectionInfo: IBCConnectionInfo): void;
+    /**
+     * @param {string | { chainId: string }} chain1
+     * @param {string | { chainId: string }} chain2
+     * @returns {Vow<IBCConnectionInfo>}
+     */
+    getConnectionInfo(chain1: string | {
+        chainId: string;
+    }, chain2: string | {
+        chainId: string;
+    }): Vow<IBCConnectionInfo>;
+    /**
+     * @template {string} C1
+     * @template {string} C2
+     * @param {C1} chainName1
+     * @param {C2} chainName2
+     * @returns {Vow<
+     *   [ActualChainInfo<C1>, ActualChainInfo<C2>, IBCConnectionInfo]
+     * >}
+     */
+    getChainsAndConnection<C1 extends string, C2 extends string>(chainName1: C1, chainName2: 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 { NameHub } from '@agoric/vats';
+import type { Remote } from '@agoric/internal';
+import type { Zone } from '@agoric/zone';
+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

@@ -0,0 +1 @@
+{"version":3,"file":"chain-hub.d.ts","sourceRoot":"","sources":["chain-hub.js"],"names":[],"mappings":"AAcA;;;;;;;GAOG;AAEH;;;;;GAKG;AAEH,wCAAwC;AACxC,gCAAiC;AACjC,kCAAkC;AAClC,gDAAiD;AAqB1C,wCAHI,MAAM,YACN,MAAM,UAUhB;AAoCM,0CAHI,OAAO,OAAO,CAAC;IAgBtB;;;;;;;;;;;OAWG;wBAFQ,MAAM,aACN,eAAe;IAK1B;;;;OAIG;iBAHmB,CAAC,SAAV,MAAQ,aACV,CAAC,GACC,IAAI,eAAe,CAAC,CAAC,CAAC,CAAC;IAoBpC;;;;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;IAqBnC;;;;;;;;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;GAsBP;4BA5LqB,CAAC,SAAV,MAAQ,IACR,CAAC,SAAS,MAAM,WAAW,GACjC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,GACnC,SAAS;uBA0LF,UAAU,CAAC,OAAO,YAAY,CAAC;6BAtMnB,cAAc;4BAIf,kBAAkB;0BACpB,cAAc;qCAHgB,kBAAkB;yBADjD,aAAa;uCACkB,kBAAkB;iCAC9B,kBAAkB;+BAAlB,kBAAkB"}

package/src/exos/chain-hub.js

@@ -0,0 +1,214 @@
+import { VowShape } from '@agoric/vow';
+// eslint-disable-next-line no-restricted-syntax
+import { heapVowTools } from '@agoric/vow/vat.js';
+import { makeHeapZone } from '@agoric/zone';
+import { E } from '@endo/far';
+import { M } from '@endo/patterns';
+import { CosmosChainInfoShape, IBCConnectionInfoShape } from '../typeGuards.js';
+
+// FIXME test thoroughly whether heap suffices for ChainHub
+// eslint-disable-next-line no-restricted-syntax
+const { allVows, watch } = heapVowTools;
+
+const { Fail } = assert;
+
+/**
+ * @import {NameHub} from '@agoric/vats';
+ * @import {Vow} from '@agoric/vow';
+ * @import {CosmosChainInfo, IBCConnectionInfo} from '../cosmos-api.js';
+ * @import {ChainInfo, KnownChains} from '../chain-info.js';
+ * @import {Remote} from '@agoric/internal';
+ * @import {Zone} from '@agoric/zone';
+ */
+
+/**
+ * @template {string} K
+ * @typedef {K extends keyof KnownChains
+ *   ? Omit<KnownChains[K], 'connections'>
+ *   : ChainInfo} ActualChainInfo
+ */
+
+/** agoricNames key for ChainInfo hub */
+export const CHAIN_KEY = 'chain';
+/** namehub for connection info */
+export const CONNECTIONS_KEY = 'chainConnection';
+
+/**
+ * Character used in a connection tuple key to separate the two chain ids. Valid
+ * because a chainId can contain only alphanumerics and dash.
+ *
+ * Vstorage keys can be only alphanumerics, dash or underscore. That leaves
+ * underscore as the only valid separator.
+ *
+ * @see {@link https://github.com/ChainAgnostic/CAIPs/blob/main/CAIPs/caip-2.md}
+ */
+const CHAIN_ID_SEPARATOR = '_';
+
+/**
+ * The entries of the top-level namehubs in agoricNames are reflected to
+ * vstorage. But only the top level. So we combine the 2 chain ids into 1 key.
+ * Connections are directionless, so we sort the ids.
+ *
+ * @param {string} chainId1
+ * @param {string} chainId2
+ */
+export const connectionKey = (chainId1, chainId2) => {
+  if (
+    chainId1.includes(CHAIN_ID_SEPARATOR) ||
+    chainId2.includes(CHAIN_ID_SEPARATOR)
+  ) {
+    Fail`invalid chain id ${chainId1} or ${chainId2}`;
+  }
+  return [chainId1, chainId2].sort().join(CHAIN_ID_SEPARATOR);
+};
+
+const ChainIdArgShape = M.or(
+  M.string(),
+  M.splitRecord(
+    {
+      chainId: M.string(),
+    },
+    undefined,
+    M.any(),
+  ),
+);
+
+const ChainHubI = M.interface('ChainHub', {
+  registerChain: M.call(M.string(), CosmosChainInfoShape).returns(),
+  getChainInfo: M.call(M.string()).returns(VowShape),
+  registerConnection: M.call(
+    M.string(),
+    M.string(),
+    IBCConnectionInfoShape,
+  ).returns(),
+  getConnectionInfo: M.call(ChainIdArgShape, ChainIdArgShape).returns(VowShape),
+  getChainsAndConnection: M.call(M.string(), M.string()).returns(VowShape),
+});
+
+/**
+ * Make a new ChainHub in the zone (or in the heap if no zone is provided).
+ *
+ * The resulting object is an Exo singleton. It has no precious state. It's only
+ * state is a cache of queries to agoricNames and whatever info was provided in
+ * registration calls. When you need a newer version you can simply make a hub
+ * hub and repeat the registrations.
+ *
+ * @param {Remote<NameHub>} agoricNames
+ * @param {Zone} [zone]
+ */
+export const makeChainHub = (agoricNames, zone = makeHeapZone()) => {
+  /** @type {MapStore<string, CosmosChainInfo>} */
+  const chainInfos = zone.mapStore('chainInfos', {
+    keyShape: M.string(),
+    valueShape: CosmosChainInfoShape,
+  });
+  /** @type {MapStore<string, IBCConnectionInfo>} */
+  const connectionInfos = zone.mapStore('connectionInfos', {
+    keyShape: M.string(),
+    valueShape: IBCConnectionInfoShape,
+  });
+
+  const chainHub = zone.exo('ChainHub', ChainHubI, {
+    /**
+     * Register a new chain. The name will override a name in well known chain
+     * names.
+     *
+     * If a durable zone was not provided, registration will not survive a
+     * reincarnation of the vat. Then if the chain is not yet in the well known
+     * names at that point, it will have to be registered again. In an unchanged
+     * contract `start` the call will happen again naturally.
+     *
+     * @param {string} name
+     * @param {CosmosChainInfo} chainInfo
+     */
+    registerChain(name, chainInfo) {
+      chainInfos.init(name, chainInfo);
+    },
+    /**
+     * @template {string} K
+     * @param {K} chainName
+     * @returns {Vow<ActualChainInfo<K>>}
+     */
+    getChainInfo(chainName) {
+      // Either from registerChain or memoized remote lookup()
+      if (chainInfos.has(chainName)) {
+        return /** @type {Vow<ActualChainInfo<K>>} */ (
+          watch(chainInfos.get(chainName))
+        );
+      }
+
+      return watch(E(agoricNames).lookup(CHAIN_KEY, chainName), {
+        onFulfilled: chainInfo => {
+          chainInfos.init(chainName, chainInfo);
+          return chainInfo;
+        },
+        onRejected: _cause => {
+          throw assert.error(`chain not found:${chainName}`);
+        },
+      });
+    },
+    /**
+     * @param {string} chainId1
+     * @param {string} chainId2
+     * @param {IBCConnectionInfo} connectionInfo
+     */
+    registerConnection(chainId1, chainId2, connectionInfo) {
+      const key = connectionKey(chainId1, chainId2);
+      connectionInfos.init(key, connectionInfo);
+    },
+
+    /**
+     * @param {string | { chainId: string }} chain1
+     * @param {string | { chainId: string }} chain2
+     * @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);
+      if (connectionInfos.has(key)) {
+        return watch(connectionInfos.get(key));
+      }
+
+      return watch(E(agoricNames).lookup(CONNECTIONS_KEY, key), {
+        onFulfilled: connectionInfo => {
+          connectionInfos.init(key, connectionInfo);
+          return connectionInfo;
+        },
+        onRejected: _cause => {
+          throw assert.error(`connection not found: ${chainId1}<->${chainId2}`);
+        },
+      });
+    },
+
+    /**
+     * @template {string} C1
+     * @template {string} C2
+     * @param {C1} chainName1
+     * @param {C2} chainName2
+     * @returns {Vow<
+     *   [ActualChainInfo<C1>, ActualChainInfo<C2>, IBCConnectionInfo]
+     * >}
+     */
+    getChainsAndConnection(chainName1, chainName2) {
+      return watch(
+        allVows([
+          chainHub.getChainInfo(chainName1),
+          chainHub.getChainInfo(chainName2),
+        ]),
+        {
+          onFulfilled: ([chain1, chain2]) => {
+            return watch(chainHub.getConnectionInfo(chain2, chain1), {
+              onFulfilled: connectionInfo => {
+                return [chain1, chain2, connectionInfo];
+              },
+            });
+          },
+        },
+      );
+    },
+  });
+
+  return chainHub;
+};
+/** @typedef {ReturnType<typeof makeChainHub>} ChainHub */