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

package/src/utils/address.js

@@ -0,0 +1,79 @@
+import { Fail } from '@agoric/assert';
+
+/**
+ * @import {IBCConnectionID} from '@agoric/vats';
+ * @import {ChainAddress} from '../types.js';
+ * @import {RemoteIbcAddress} from '@agoric/vats/tools/ibc-utils.js';
+ */
+
+/**
+ * @param {IBCConnectionID} hostConnectionId Counterpart Connection ID
+ * @param {IBCConnectionID} controllerConnectionId Self Connection ID
+ * @param {object} [opts]
+ * @param {string} [opts.encoding] - message encoding format for the channel.
+ *   default is `proto3`
+ * @param {'ordered' | 'unordered'} [opts.ordering] - channel ordering.
+ *   currently only `ordered` is supported for ics27-1
+ * @param {string} [opts.txType] - default is `sdk_multi_msg`
+ * @param {string} [opts.version] - default is `ics27-1`
+ * @returns {RemoteIbcAddress}
+ */
+export const makeICAChannelAddress = (
+  hostConnectionId,
+  controllerConnectionId,
+  {
+    version = 'ics27-1',
+    encoding = 'proto3',
+    ordering = 'ordered',
+    txType = 'sdk_multi_msg',
+  } = {},
+) => {
+  hostConnectionId || Fail`hostConnectionId is required`;
+  controllerConnectionId || Fail`controllerConnectionId is required`;
+  const connString = JSON.stringify({
+    version,
+    controllerConnectionId,
+    hostConnectionId,
+    address: '', // will be provided by the counterparty after channelOpenAck
+    encoding,
+    txType,
+  });
+  return `/ibc-hop/${controllerConnectionId}/ibc-port/icahost/${ordering}/${connString}`;
+};
+harden(makeICAChannelAddress);
+
+/**
+ * @param {IBCConnectionID} controllerConnectionId
+ * @param {{ version?: string }} [opts]
+ * @returns {RemoteIbcAddress}
+ */
+export const makeICQChannelAddress = (
+  controllerConnectionId,
+  { version = 'icq-1' } = {},
+) => {
+  controllerConnectionId || Fail`controllerConnectionId is required`;
+  return `/ibc-hop/${controllerConnectionId}/ibc-port/icqhost/unordered/${version}`;
+};
+harden(makeICQChannelAddress);
+
+/**
+ * Parse a chain address from a remote address string. Assumes the address
+ * string is in a JSON format and contains an "address" field. This function is
+ * designed to be safe against malformed inputs and unexpected data types, and
+ * will return `undefined` in those cases.
+ *
+ * @param {RemoteIbcAddress} remoteAddressString - remote address string,
+ *   including version
+ * @returns {ChainAddress['address'] | undefined} returns undefined on error
+ */
+export const findAddressField = remoteAddressString => {
+  try {
+    // Extract JSON version string assuming it's always surrounded by {}
+    const jsonStr = remoteAddressString?.match(/{.*?}/)?.[0];
+    const jsonObj = jsonStr ? JSON.parse(jsonStr) : undefined;
+    return jsonObj?.address ?? undefined;
+  } catch (error) {
+    return undefined;
+  }
+};
+harden(findAddressField);

package/src/utils/cosmos.d.ts

@@ -0,0 +1,9 @@
+/** maximum clock skew, in seconds, for unbonding time reported from other chain */
+export const maxClockSkew: bigint;
+export function encodeTxResponse(response: unknown, toProtoMsg: (msg: any) => Any): string;
+export function tryDecodeResponse<T>(ackStr: string, fromProtoMsg: (p: {
+    typeUrl: string;
+    value: Uint8Array;
+}) => T): T;
+import { Any } from '@agoric/cosmic-proto/google/protobuf/any.js';
+//# sourceMappingURL=cosmos.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cosmos.d.ts","sourceRoot":"","sources":["cosmos.js"],"names":[],"mappings":"AAIA,mFAAmF;AACnF,kCAAsC;AAO/B,2CAJI,OAAO,cACP,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,GACf,MAAM,CAQlB;AAOM,kCAJM,CAAC,UACH,MAAM,gBACN,CAAC,CAAC,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAE,KAAK,CAAC,KAY1D;oBAlCmB,6CAA6C"}

package/src/utils/cosmos.js

@@ -0,0 +1,36 @@
+import { assert } from '@agoric/assert';
+import { Any } from '@agoric/cosmic-proto/google/protobuf/any.js';
+import { decodeBase64, encodeBase64 } from '@endo/base64';
+
+/** maximum clock skew, in seconds, for unbonding time reported from other chain */
+export const maxClockSkew = 10n * 60n;
+
+/**
+ * @param {unknown} response
+ * @param {(msg: any) => Any} toProtoMsg
+ * @returns {string}
+ */
+export const encodeTxResponse = (response, toProtoMsg) => {
+  const protoMsg = toProtoMsg(response);
+  const any1 = Any.fromPartial(protoMsg);
+  const any2 = Any.fromPartial({ value: Any.encode(any1).finish() });
+  const ackStr = encodeBase64(Any.encode(any2).finish());
+  return ackStr;
+};
+
+/**
+ * @template T
+ * @param {string} ackStr
+ * @param {(p: { typeUrl: string; value: Uint8Array }) => T} fromProtoMsg
+ */
+export const tryDecodeResponse = (ackStr, fromProtoMsg) => {
+  try {
+    const any = Any.decode(decodeBase64(ackStr));
+    const protoMsg = Any.decode(any.value);
+
+    const msg = fromProtoMsg(protoMsg);
+    return msg;
+  } catch (cause) {
+    throw assert.error(`bad response: ${ackStr}`, undefined, { cause });
+  }
+};

package/src/utils/orc.d.ts

@@ -0,0 +1,17 @@
+export namespace orcUtils {
+    function makeTransferMsg(_args: Omit<TransferMsg, "memo">): TransferMsg;
+    /**
+     * SwapExact or SwapMaxSlippage, with optional AfterAction
+     *
+     * @param {(SwapExact | SwapMaxSlippage) &
+     *   (AfterAction | Record<string, never>)} _args
+     *
+     * @returns {TransferMsg}
+     */
+    function makeOsmosisSwap(_args: (SwapExact | SwapMaxSlippage) & (AfterAction | Record<string, never>)): TransferMsg;
+}
+import type { TransferMsg } from '../types.js';
+import type { SwapExact } from '../types.js';
+import type { SwapMaxSlippage } from '../types.js';
+import type { AfterAction } from '../types.js';
+//# sourceMappingURL=orc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"orc.d.ts","sourceRoot":"","sources":["orc.js"],"names":[],"mappings":";IASmB,gCAHN,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,GACvB,WAAW,CAWvB;IACD;;;;;;;OAOG;IACH,gCALW,CAAC,SAAS,GAAG,eAAe,CAAC,GACvC,CAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,GAE7B,WAAW,CAWvB;;iCApCqE,aAAa;+BAAb,aAAa;qCAAb,aAAa;iCAAb,aAAa"}

package/src/utils/orc.js

@@ -0,0 +1,38 @@
+/** @import {AfterAction, SwapExact, SwapMaxSlippage, TransferMsg} from '../types.js' */
+
+export const orcUtils = {
+  /**
+   * unwinds denom with PFM, if necessary
+   *
+   * @param {Omit<TransferMsg, 'memo'>} _args
+   * @returns {TransferMsg}
+   */
+  makeTransferMsg: _args => {
+    // FIXME mocked, so typescript is happy
+    return {
+      toAccount: {
+        chainId: 'osmosis-test',
+        address: 'osmo1234',
+        addressEncoding: 'bech32',
+      },
+    };
+  },
+  /**
+   * SwapExact or SwapMaxSlippage, with optional AfterAction
+   *
+   * @param {(SwapExact | SwapMaxSlippage) &
+   *   (AfterAction | Record<string, never>)} _args
+   *
+   * @returns {TransferMsg}
+   */
+  makeOsmosisSwap(_args) {
+    // FIXME mocked, so typescript is happy
+    return {
+      toAccount: {
+        chainId: 'osmosis-test',
+        address: 'osmo1234',
+        addressEncoding: 'bech32',
+      },
+    };
+  },
+};

package/src/utils/orchestrationAccount.d.ts

@@ -0,0 +1,10 @@
+export namespace orchestrationAccountMethods {
+    let getAddress: import("@endo/patterns").MethodGuard;
+    let getBalance: import("@endo/patterns").MethodGuard;
+    let getBalances: import("@endo/patterns").MethodGuard;
+    let send: import("@endo/patterns").MethodGuard;
+    let transfer: import("@endo/patterns").MethodGuard;
+    let transferSteps: import("@endo/patterns").MethodGuard;
+    let deposit: import("@endo/patterns").MethodGuard;
+}
+//# sourceMappingURL=orchestrationAccount.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrationAccount.d.ts","sourceRoot":"","sources":["orchestrationAccount.js"],"names":[],"mappings":""}

package/src/utils/orchestrationAccount.js

@@ -0,0 +1,22 @@
+import { M } from '@endo/patterns';
+import { PaymentShape } from '@agoric/ertp';
+import { Shape as NetworkShape } from '@agoric/network';
+import { VowShape } from '@agoric/vow';
+import { AmountArgShape, ChainAddressShape, CoinShape } from '../typeGuards.js';
+
+/** @import {OrchestrationAccountI} from '../orchestration-api.js'; */
+
+const { Vow$ } = NetworkShape; // TODO #9611
+
+/** @see {OrchestrationAccountI} */
+export const orchestrationAccountMethods = {
+  getAddress: M.call().returns(ChainAddressShape),
+  getBalance: M.call(M.any()).returns(Vow$(CoinShape)),
+  getBalances: M.call().returns(Vow$(M.arrayOf(CoinShape))),
+  send: M.call(ChainAddressShape, AmountArgShape).returns(VowShape),
+  transfer: M.call(AmountArgShape, ChainAddressShape)
+    .optional(M.record())
+    .returns(VowShape),
+  transferSteps: M.call(AmountArgShape, M.any()).returns(VowShape),
+  deposit: M.call(PaymentShape).returns(VowShape),
+};

package/src/utils/packet.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @import {AnyJson, JsonSafe} from '@agoric/cosmic-proto';
+ * @import {InterchainAccountPacketData} from '@agoric/cosmic-proto/ibc/applications/interchain_accounts/v1/packet.js';
+ * @import {InterchainQueryPacketData} from '@agoric/cosmic-proto/icq/v1/packet.js';
+ */
+/**
+ * Makes an IBC transaction packet from an array of messages. Expects the
+ * `value` of each message to be base64 encoded bytes. Skips checks for
+ * malformed messages in favor of interface guards.
+ *
+ * @param {AnyJson[]} msgs
+ * @param {Partial<Omit<TxBody, 'messages'>>} [opts]
+ * @returns {string} stringified InterchainAccountPacketData
+ * @throws {Error} if malformed messages are provided
+ */
+export function makeTxPacket(msgs: AnyJson[], opts?: Partial<Omit<TxBody, "messages">> | undefined): string;
+/**
+ * Makes an IBC query packet from an array of query messages. Expects the `data`
+ * of each message to be base64 encoded bytes. Skips checks for malformed
+ * messages in favor of interface guards.
+ *
+ * @param {JsonSafe<RequestQuery>[]} msgs
+ * @returns {string} stringified InterchainQueryPacketData
+ * @throws {Error} if malformed messages are provided
+ */
+export function makeQueryPacket(msgs: JsonSafe<RequestQuery>[]): string;
+/**
+ * Looks for a result or error key in the response string, and returns a
+ * Base64Bytes string. This string can be decoded using the corresponding
+ * Msg*Response object. Error strings seem to be plain text and do not need
+ * decoding.
+ *
+ * @param {string} response
+ * @returns {string} - base64 encoded bytes string
+ * @throws {Error} if error key is detected in response string, or result key is
+ *   not found
+ */
+export function parseTxPacket(response: string): string;
+/**
+ * Looks for a result or error key in the response string. If a result is found,
+ * `responses` is decoded via `CosmosResponse`. The `key` and `value` fields on
+ * the resulting entries are base64 encoded for inter-vat communication. These
+ * can be decoded using the corresponding Query*Response objects. Error strings
+ * seem to be plain text and do not need decoding.
+ *
+ * @param {string} response
+ * @returns {JsonSafe<ResponseQuery>[]}
+ * @throws {Error} if error key is detected in response string, or result key is
+ *   not found
+ */
+export function parseQueryPacket(response: string): JsonSafe<ResponseQuery>[];
+import type { AnyJson } from '@agoric/cosmic-proto';
+import { TxBody } from '@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js';
+import { RequestQuery } from '@agoric/cosmic-proto/tendermint/abci/types.js';
+import type { JsonSafe } from '@agoric/cosmic-proto';
+import { ResponseQuery } from '@agoric/cosmic-proto/tendermint/abci/types.js';
+//# sourceMappingURL=packet.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"packet.d.ts","sourceRoot":"","sources":["packet.js"],"names":[],"mappings":"AAcA;;;;GAIG;AAEH;;;;;;;;;GASG;AACH,mCALW,OAAO,EAAE,yDAEP,MAAM,CAmBlB;AAGD;;;;;;;;GAQG;AACH,sCAJW,SAAS,YAAY,CAAC,EAAE,GACtB,MAAM,CAgBlB;AAGD;;;;;;;;;;GAUG;AACH,wCALW,MAAM,GACJ,MAAM,CASlB;AAGD;;;;;;;;;;;GAWG;AACH,2CALW,MAAM,GACJ,SAAS,aAAa,CAAC,EAAE,CASrC;6BA/FmC,sBAAsB;uBAdnC,8CAA8C;6BAK9D,+CAA+C;8BASlB,sBAAsB;8BATnD,+CAA+C"}

package/src/utils/packet.js

@@ -0,0 +1,112 @@
+import { Fail } from '@endo/errors';
+import { TxBody } from '@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js';
+import { Any } from '@agoric/cosmic-proto/google/protobuf/any.js';
+import {
+  RequestQuery,
+  ResponseQuery,
+} from '@agoric/cosmic-proto/tendermint/abci/types.js';
+import { atob, decodeBase64, encodeBase64 } from '@endo/base64';
+import {
+  CosmosQuery,
+  CosmosResponse,
+} from '@agoric/cosmic-proto/icq/v1/packet.js';
+import { Type as PacketType } from '@agoric/cosmic-proto/ibc/applications/interchain_accounts/v1/packet.js';
+
+/**
+ * @import {AnyJson, JsonSafe} from '@agoric/cosmic-proto';
+ * @import {InterchainAccountPacketData} from '@agoric/cosmic-proto/ibc/applications/interchain_accounts/v1/packet.js';
+ * @import {InterchainQueryPacketData} from '@agoric/cosmic-proto/icq/v1/packet.js';
+ */
+
+/**
+ * Makes an IBC transaction packet from an array of messages. Expects the
+ * `value` of each message to be base64 encoded bytes. Skips checks for
+ * malformed messages in favor of interface guards.
+ *
+ * @param {AnyJson[]} msgs
+ * @param {Partial<Omit<TxBody, 'messages'>>} [opts]
+ * @returns {string} stringified InterchainAccountPacketData
+ * @throws {Error} if malformed messages are provided
+ */
+export function makeTxPacket(msgs, opts) {
+  const messages = msgs.map(Any.fromJSON);
+  const bytes = TxBody.encode(
+    TxBody.fromPartial({
+      messages,
+      ...opts,
+    }),
+  ).finish();
+
+  return JSON.stringify(
+    /** @type {JsonSafe<InterchainAccountPacketData>} */ ({
+      type: PacketType.TYPE_EXECUTE_TX,
+      data: encodeBase64(bytes),
+      memo: '',
+    }),
+  );
+}
+harden(makeTxPacket);
+
+/**
+ * Makes an IBC query packet from an array of query messages. Expects the `data`
+ * of each message to be base64 encoded bytes. Skips checks for malformed
+ * messages in favor of interface guards.
+ *
+ * @param {JsonSafe<RequestQuery>[]} msgs
+ * @returns {string} stringified InterchainQueryPacketData
+ * @throws {Error} if malformed messages are provided
+ */
+export function makeQueryPacket(msgs) {
+  const bytes = CosmosQuery.encode(
+    CosmosQuery.fromPartial({
+      requests: msgs.map(RequestQuery.fromJSON),
+    }),
+  ).finish();
+
+  return JSON.stringify(
+    /** @type {JsonSafe<InterchainQueryPacketData>} */ ({
+      data: encodeBase64(bytes),
+      memo: '',
+    }),
+  );
+}
+harden(makeQueryPacket);
+
+/**
+ * Looks for a result or error key in the response string, and returns a
+ * Base64Bytes string. This string can be decoded using the corresponding
+ * Msg*Response object. Error strings seem to be plain text and do not need
+ * decoding.
+ *
+ * @param {string} response
+ * @returns {string} - base64 encoded bytes string
+ * @throws {Error} if error key is detected in response string, or result key is
+ *   not found
+ */
+export function parseTxPacket(response) {
+  const { result, error } = JSON.parse(response);
+  if (result) return result;
+  else if (error) throw Error(error);
+  else throw Fail`expected either result or error: ${response}`;
+}
+harden(parseTxPacket);
+
+/**
+ * Looks for a result or error key in the response string. If a result is found,
+ * `responses` is decoded via `CosmosResponse`. The `key` and `value` fields on
+ * the resulting entries are base64 encoded for inter-vat communication. These
+ * can be decoded using the corresponding Query*Response objects. Error strings
+ * seem to be plain text and do not need decoding.
+ *
+ * @param {string} response
+ * @returns {JsonSafe<ResponseQuery>[]}
+ * @throws {Error} if error key is detected in response string, or result key is
+ *   not found
+ */
+export function parseQueryPacket(response) {
+  const result = parseTxPacket(response);
+  const { data } = JSON.parse(atob(result));
+  const { responses = [] } = CosmosResponse.decode(decodeBase64(data));
+  return harden(responses.map(ResponseQuery.toJSON));
+}
+harden(parseQueryPacket);

package/src/utils/registry.d.ts

@@ -0,0 +1,13 @@
+export function convertChainInfo(registry: Pick<ChainRegistryClient, "chains" | "ibcData">): Promise<{
+    [k: string]: Readonly<{
+        chainId: string;
+        connections?: Record<string, IBCConnectionInfo>;
+        icqEnabled?: boolean;
+        stakingTokens?: Readonly<Array<{
+            denom: string;
+        }>>;
+    }>;
+}>;
+import type { ChainRegistryClient } from '@chain-registry/client';
+import type { IBCConnectionInfo } from '../cosmos-api.js';
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["registry.js"],"names":[],"mappings":"AAwFO,2CAFI,IAAI,CAAC,mBAAmB,EAAE,QAAQ,GAAG,SAAS,CAAC;;;;;;;;;GA4CzD;yCAxHqC,wBAAwB;uCACT,kBAAkB"}

package/src/utils/registry.js

@@ -0,0 +1,131 @@
+import {
+  State as IBCChannelState,
+  Order,
+} from '@agoric/cosmic-proto/ibc/core/channel/v1/channel.js';
+import { State as IBCConnectionState } from '@agoric/cosmic-proto/ibc/core/connection/v1/connection.js';
+import assert from 'node:assert';
+
+/**
+ * @import {IBCChannelID, IBCConnectionID} from '@agoric/vats';
+ * @import {Chain, IBCInfo} from '@chain-registry/types';
+ * @import {ChainRegistryClient} from '@chain-registry/client';
+ * @import {CosmosChainInfo, IBCConnectionInfo} from '../cosmos-api.js';
+ */
+
+/**
+ * @param {IBCInfo} ibcInfo
+ * @param {string} name
+ * @param {Record<string, CosmosChainInfo>} chainInfo
+ * @returns {[string, IBCConnectionInfo] | []}
+ */
+function toConnectionEntry(ibcInfo, name, chainInfo) {
+  // IbcInfo encodes the undirected edge as a tuple of (chain_1, chain_2) in alphabetical order
+  const fromChain1 = ibcInfo.chain_1.chain_name === name;
+  const [from, to] = fromChain1
+    ? [ibcInfo.chain_1, ibcInfo.chain_2]
+    : [ibcInfo.chain_2, ibcInfo.chain_1];
+  assert.equal(from.chain_name, name);
+  const transferChannels = ibcInfo.channels.filter(
+    c =>
+      c.chain_1.port_id === 'transfer' &&
+      // @ts-expect-error tags does not specify keys
+      c.tags?.preferred,
+  );
+  if (transferChannels.length === 0) {
+    console.warn(
+      'no transfer channel for [',
+      from.chain_name,
+      to.chain_name,
+      ']',
+      '(skipping)',
+    );
+    return [];
+  }
+  if (transferChannels.length > 1) {
+    console.warn(
+      'multiple preferred transfer channels [',
+      from.chain_name,
+      to.chain_name,
+      ']:',
+      transferChannels,
+      '(choosing first)',
+    );
+  }
+  const [channel] = transferChannels;
+  const [channelFrom, channelTo] = fromChain1
+    ? [channel.chain_2, channel.chain_1]
+    : [channel.chain_1, channel.chain_2];
+  const record = {
+    id: /** @type {IBCConnectionID} */ (from.connection_id),
+    client_id: from.client_id,
+    counterparty: {
+      client_id: to.client_id,
+      connection_id: /** @type {IBCConnectionID} */ (to.connection_id),
+      prefix: {
+        key_prefix: 'FIXME',
+      },
+    },
+    state: IBCConnectionState.STATE_OPEN, // XXX presumably
+    transferChannel: {
+      channelId: /** @type {IBCChannelID} */ (channelFrom.channel_id),
+      portId: channelFrom.port_id,
+      counterPartyChannelId: /** @type {IBCChannelID} */ (channelTo.channel_id),
+      counterPartyPortId: channelTo.port_id,
+      // FIXME mapping, our guard expects a numerical enum
+      ordering: Order.ORDER_NONE_UNSPECIFIED,
+      state: IBCChannelState.STATE_OPEN, // XXX presumably
+      version: channel.version,
+    },
+  };
+  const destChainId = chainInfo[to.chain_name].chainId;
+  return [destChainId, record];
+}
+
+/**
+ * Converts the given chain info to our local config format
+ *
+ * @param {Pick<ChainRegistryClient, 'chains' | 'ibcData'>} registry
+ */
+export const convertChainInfo = async registry => {
+  /** @type {Record<string, CosmosChainInfo>} */
+  const chainInfo = {};
+
+  for (const chain of registry.chains) {
+    console.log('processing info', chain.chain_name);
+    chainInfo[chain.chain_name] = {
+      chainId: chain.chain_id,
+      stakingTokens: chain.staking?.staking_tokens,
+      // UNTIL https://github.com/Agoric/agoric-sdk/issues/9326
+      icqEnabled: chain.chain_name === 'osmosis',
+    };
+  }
+
+  // XXX probably easier to keep ibc separate
+  const ibcLookup = {};
+  for (const ibc of registry.ibcData) {
+    ibcLookup[ibc.chain_1.chain_name] ||= [];
+    ibcLookup[ibc.chain_2.chain_name] ||= [];
+
+    ibcLookup[ibc.chain_1.chain_name].push(ibc);
+    ibcLookup[ibc.chain_2.chain_name].push(ibc);
+  }
+
+  const chainNames = registry.chains.map(c => c.chain_name).sort();
+
+  // iterate this after chainInfo is filled out
+  for (const name of chainNames) {
+    console.log('processing connections', name);
+
+    const ibcData = ibcLookup[name];
+    const connections = Object.fromEntries(
+      ibcData
+        .map(datum => toConnectionEntry(datum, name, chainInfo))
+        // sort alphabetically for consistency
+        .sort(([a], [b]) => (a && b ? a.localeCompare(b) : 0)),
+    );
+    chainInfo[name] = { ...chainInfo[name], connections };
+  }
+
+  // return object with insertion in alphabetical order of chain name
+  return Object.fromEntries(chainNames.map(name => [name, chainInfo[name]]));
+};

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

@@ -0,0 +1,51 @@
+export function provideOrchestration(zcf: ZCF, baggage: Baggage, remotePowers: OrchestrationPowers, marshaller: Marshaller): {
+    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 | {
+            chainId: string;
+        }, chain2: 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]>;
+    }>;
+    vowTools: {
+        E: (<T>(x: T, opts?: import("@agoric/vow").EUnwrapOptions | undefined) => ECallableOrMethods<RemoteFunctions<T>>) & {
+            readonly get: <T>(x: T, opts?: import("@agoric/vow").EUnwrapOptions | undefined) => EGetters<LocalRecord<T>>;
+            readonly resolve: <T>(x: T, opts?: import("@agoric/vow").EUnwrapOptions | undefined) => Promise<Awaited<T>>;
+            readonly sendOnly: <T>(x: T, opts?: import("@agoric/vow").EUnwrapOptions | undefined) => ESendOnlyCallableOrMethods<RemoteFunctions<T>>;
+            readonly when: <T, TResult1 = import("@agoric/vow").EUnwrap<T>, TResult2 = never>(x: globalThis.ERef<T>, onfulfilled?: ((value: import("@agoric/vow").EUnwrap<T>) => import("@agoric/vow/src/E.js").ERef<TResult1>) | undefined, onrejected?: ((reason: any) => import("@agoric/vow/src/E.js").ERef<TResult2>) | undefined, opts?: import("@agoric/vow").EUnwrapOptions | undefined) => Promise<TResult1 | TResult2>;
+        } & {
+            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 = any, TResult1 = T, TResult2 = never, C extends any[] = any[]>(specimenP: import("@agoric/vow").EVow<T>, watcher?: import("@agoric/vow").Watcher<T, TResult1, TResult2, C> | undefined, ...watcherArgs: C) => import("@agoric/vow").Vow<Exclude<TResult1, void> | Exclude<TResult2, void> extends never ? TResult1 : Exclude<TResult1, void> | Exclude<TResult2, void>>;
+        };
+        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 = any, TResult1 = T, TResult2 = never, C extends any[] = any[]>(specimenP: import("@agoric/vow").EVow<T>, watcher?: import("@agoric/vow").Watcher<T, TResult1, TResult2, C> | undefined, ...watcherArgs: C) => import("@agoric/vow").Vow<Exclude<TResult1, void> | Exclude<TResult2, void> extends never ? TResult1 : Exclude<TResult1, void> | Exclude<TResult2, void>>;
+        makeVowKit: <T>() => import("@agoric/vow").VowKit<T>;
+        allVows: (maybeVows: import("@agoric/vow").EVow<unknown>[]) => import("@agoric/vow").Vow<any[]>;
+        asVow: <T extends unknown>(fn: (...args: any[]) => import("@agoric/vow").Vow<Awaited<T>> | Awaited<T> | import("@agoric/vow").PromiseVow<T>) => import("@agoric/vow").Vow<Awaited<T>>;
+        asPromise: import("@agoric/vow").AsPromiseFunction;
+    };
+    zone: import("@agoric/base-zone").Zone;
+    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>;
+    adminAsyncFlow: import("@endo/exo").Guarded<{
+        getFailures(): import("@endo/patterns").CopyMap<any, import("@endo/pass-style").Passable>;
+        wakeAll(): void;
+        getFlowForOutcomeVow(outcomeVow: any): any;
+    }>;
+};
+export type OrchestrationPowers = {
+    localchain: Remote<LocalChain>;
+    orchestrationService: Remote<OrchestrationService>;
+    storageNode: Remote<StorageNode>;
+    timerService: Remote<TimerService>;
+    agoricNames: Remote<NameHub>;
+};
+import type { Baggage } from '@agoric/vat-data';
+import type { LocalChain } from '@agoric/vats/src/localchain.js';
+import type { Remote } from '@agoric/vow';
+import type { OrchestrationService } from '../service.js';
+import type { TimerService } from '@agoric/time';
+import type { NameHub } from '@agoric/vats';
+//# sourceMappingURL=start-helper.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"start-helper.d.ts","sourceRoot":"","sources":["start-helper.js"],"names":[],"mappings":"AAwCO,0CALI,GAAG,WACH,OAAO,gBACP,mBAAmB,cACnB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;wCAmDN,GAAG;;;;4PAmBK,GACjB,4CAA4E,GAAG;;;;;;EAFpF;kCArFY;IACZ,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;CAC9B;6BAbsB,kBAAkB;gCAFf,gCAAgC;4BAIpC,aAAa;0CACC,eAAe;kCAJX,cAAc;6BAE/B,cAAc"}