@agoric/orchestration 0.2.0-upgrade-18-dev-aaebae4.0 → 0.2.0-upgrade-18-dev-bd8fd54.0

package/src/typeGuards.js

@@ -1,13 +1,15 @@
+import { BrandShape } from '@agoric/ertp/src/typeGuards.js';
 import { VowShape } from '@agoric/vow';
 import { M } from '@endo/patterns';
 
 /**
  * @import {TypedPattern} from '@agoric/internal';
- * @import {ChainAddress, CosmosAssetInfo, Chain, ChainInfo, CosmosChainInfo, DenomAmount, DenomDetail, DenomInfo, AmountArg, CosmosValidatorAddress} from './types.js';
+ * @import {ChainAddress, CosmosAssetInfo, Chain, ChainInfo, CosmosChainInfo, DenomAmount, DenomInfo, AmountArg, CosmosValidatorAddress, OrchestrationPowers, ForwardInfo, IBCMsgTransferOptions} from './types.js';
  * @import {Any as Proto3Msg} from '@agoric/cosmic-proto/google/protobuf/any.js';
- * @import {Delegation} from '@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js';
  * @import {TxBody} from '@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js';
+ * @import {Coin} from '@agoric/cosmic-proto/cosmos/base/v1beta1/coin.js';
  * @import {TypedJson} from '@agoric/cosmic-proto';
+ * @import {DenomDetail} from './exos/chain-hub.js';
  */
 
 /**
@@ -31,28 +33,15 @@ export const ChainAddressShape = {
   encoding: M.string(),
   value: M.string(),
 };
+harden(ChainAddressShape);
 
 /** @type {TypedPattern<Proto3Msg>} */
-export const Proto3Shape = {
-  typeUrl: M.string(),
-  value: M.string(),
-};
-
-/** @internal */
-export const IBCTransferOptionsShape = M.splitRecord(
-  {},
-  {
-    timeoutTimestamp: M.bigint(),
-    timeoutHeight: {
-      revisionHeight: M.bigint(),
-      revisionNumber: M.bigint(),
-    },
-    memo: M.string(),
-  },
-);
+export const Proto3Shape = { typeUrl: M.string(), value: M.string() };
+harden(ChainAddressShape);
 
 /** @internal */
 export const IBCChannelIDShape = M.string();
+
 /** @internal */
 export const IBCChannelInfoShape = M.splitRecord({
   portId: M.string(),
@@ -63,8 +52,10 @@ export const IBCChannelInfoShape = M.splitRecord({
   state: M.scalar(), // XXX
   version: M.string(),
 });
+
 /** @internal */
 export const IBCConnectionIDShape = M.string();
+
 /** @internal */
 export const IBCConnectionInfoShape = M.splitRecord({
   id: IBCConnectionIDShape,
@@ -94,10 +85,12 @@ export const CosmosChainInfoShape = M.splitRecord(
     chainId: M.string(),
   },
   {
+    bech32Prefix: M.string(),
     connections: M.record(),
     stakingTokens: M.arrayOf({ denom: M.string() }),
     // UNTIL https://github.com/Agoric/agoric-sdk/issues/9326
     icqEnabled: M.boolean(),
+    pfmEnabled: M.boolean(),
   },
 );
 
@@ -107,6 +100,14 @@ export const ChainInfoShape = M.splitRecord({
 });
 export const DenomShape = M.string();
 
+/** @type {TypedPattern<Coin>} */
+export const CoinShape = {
+  /** json-safe stringified bigint */
+  amount: M.string(),
+  denom: DenomShape,
+};
+harden(CoinShape);
+
 /** @type {TypedPattern<DenomInfo<any, any>>} */
 export const DenomInfoShape = {
   chain: M.remotable('Chain'),
@@ -114,15 +115,25 @@ export const DenomInfoShape = {
   brand: M.or(M.remotable('Brand'), M.undefined()),
   baseDenom: M.string(),
 };
+harden(DenomInfoShape);
+
+/** @type {TypedPattern<DenomDetail>} */
+export const DenomDetailShape = M.splitRecord(
+  { chainName: M.string(), baseName: M.string(), baseDenom: M.string() },
+  { brand: BrandShape },
+);
+harden(DenomDetailShape);
 
 /** @type {TypedPattern<DenomAmount>} */
-export const DenomAmountShape = { denom: DenomShape, value: M.bigint() };
+export const DenomAmountShape = { denom: DenomShape, value: M.nat() };
+harden(DenomAmountShape);
 
 /** @type {TypedPattern<Amount<'nat'>>} */
-export const AnyNatAmountShape = harden({
+export const AnyNatAmountShape = {
   brand: M.remotable('Brand'),
   value: M.nat(),
-});
+};
+harden(AnyNatAmountShape);
 
 /** @type {TypedPattern<AmountArg>} */
 export const AmountArgShape = M.or(AnyNatAmountShape, DenomAmountShape);
@@ -151,10 +162,11 @@ export const ICQMsgShape = M.splitRecord(
 export const TypedJsonShape = M.splitRecord({ '@type': M.string() });
 
 /** @see {Chain} */
-export const chainFacadeMethods = harden({
+export const chainFacadeMethods = {
   getChainInfo: M.call().returns(VowShape),
   makeAccount: M.call().returns(VowShape),
-});
+};
+harden(chainFacadeMethods);
 
 /**
  * for google/protobuf/timestamp.proto, not to be confused with TimestampShape
@@ -164,6 +176,7 @@ export const chainFacadeMethods = harden({
  * string
  */
 export const TimestampProtoShape = { seconds: M.string(), nanos: M.number() };
+harden(TimestampProtoShape);
 
 /**
  * see {@link TxBody} for more details
@@ -186,6 +199,70 @@ export const TxBodyOptsShape = M.splitRecord(
  */
 export const AnyNatAmountsRecord = M.and(
   M.recordOf(M.string(), AnyNatAmountShape),
-  M.not(harden({})),
+  M.not({}),
+);
+
+/** @type {TypedPattern<OrchestrationPowers>} */
+export const OrchestrationPowersShape = {
+  agoricNames: M.remotable(),
+  localchain: M.remotable(),
+  orchestrationService: M.remotable(),
+  storageNode: M.remotable(),
+  timerService: M.remotable(),
+};
+harden(OrchestrationPowersShape);
+
+const ForwardArgsShape = {
+  receiver: M.string(),
+  port: 'transfer',
+  channel: M.string(),
+  timeout: M.string(),
+  retries: M.number(),
+};
+harden(ForwardArgsShape);
+
+/** @type {TypedPattern<ForwardInfo>} */
+export const ForwardInfoShape = {
+  forward: M.splitRecord(ForwardArgsShape, {
+    /**
+     * Protocol allows us to recursively include `next` keys, but this only
+     * supports one. In practice, this is all we currently need.
+     */
+    next: {
+      forward: ForwardArgsShape,
+    },
+  }),
+};
+harden(ForwardInfoShape);
+
+/**
+ * Caller configurable values of {@link ForwardInfo}
+ *
+ * @type {TypedPattern<IBCMsgTransferOptions['forwardOpts']>}
+ */
+export const ForwardOptsShape = M.splitRecord(
+  {},
+  {
+    timeout: M.string(),
+    retries: M.number(),
+    intermediateRecipient: ChainAddressShape,
+  },
+  {},
+);
+
+/**
+ * @type {TypedPattern<IBCMsgTransferOptions>}
+ * @internal
+ */
+export const IBCTransferOptionsShape = M.splitRecord(
+  {},
+  {
+    timeoutTimestamp: M.bigint(),
+    timeoutHeight: {
+      revisionHeight: M.bigint(),
+      revisionNumber: M.bigint(),
+    },
+    memo: M.string(),
+    forwardOpts: ForwardOptsShape,
+  },
 );
-harden(AnyNatAmountsRecord);

package/src/types.d.ts

@@ -12,6 +12,7 @@ export type * from './exos/local-chain-facade.js';
 export type * from './exos/portfolio-holder-kit.js';
 export type * from './orchestration-api.js';
 export type * from './vat-orchestration.js';
+export type * from './utils/start-helper.js';
 /**
  * ({@link ZCF})-like tools for use in {@link OrchestrationFlow}s.
  */

package/src/types.d.ts.map

@@ -1 +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,qBAAqB,CAAC;AACzC,mBAAmB,qCAAqC,CAAC;AACzD,mBAAmB,qCAAqC,CAAC;AACzD,mBAAmB,0BAA0B,CAAC;AAC9C,mBAAmB,2BAA2B,CAAC;AAC/C,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,gCAAgC,CAAC;AACpD,mBAAmB,wBAAwB,CAAC;AAC5C,mBAAmB,wBAAwB,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,mBAAmB,EAAE,GAAG,CAAC,qBAAqB,CAAC,CAAC;IAChD,eAAe,EAAE,GAAG,CAAC,iBAAiB,CAAC,CAAC;IACxC,cAAc,EAAE,GAAG,CAAC,gBAAgB,CAAC,CAAC;CACvC"}
+{"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,qBAAqB,CAAC;AACzC,mBAAmB,qCAAqC,CAAC;AACzD,mBAAmB,qCAAqC,CAAC;AACzD,mBAAmB,0BAA0B,CAAC;AAC9C,mBAAmB,2BAA2B,CAAC;AAC/C,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,8BAA8B,CAAC;AAClD,mBAAmB,gCAAgC,CAAC;AACpD,mBAAmB,wBAAwB,CAAC;AAC5C,mBAAmB,wBAAwB,CAAC;AAC5C,mBAAmB,yBAAyB,CAAC;AAE7C;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,mBAAmB,EAAE,GAAG,CAAC,qBAAqB,CAAC,CAAC;IAChD,eAAe,EAAE,GAAG,CAAC,iBAAiB,CAAC,CAAC;IACxC,cAAc,EAAE,GAAG,CAAC,gBAAgB,CAAC,CAAC;CACvC"}

package/src/types.ts

@@ -13,6 +13,7 @@ export type * from './exos/local-chain-facade.js';
 export type * from './exos/portfolio-holder-kit.js';
 export type * from './orchestration-api.js';
 export type * from './vat-orchestration.js';
+export type * from './utils/start-helper.js';
 
 /**
  * ({@link ZCF})-like tools for use in {@link OrchestrationFlow}s.

package/src/utils/address.d.ts

@@ -1,7 +1,8 @@
-export function makeICAChannelAddress(hostConnectionId: IBCConnectionID, controllerConnectionId: IBCConnectionID, { version, encoding, ordering, txType, }?: ICAChannelAddressOpts | undefined): RemoteIbcAddress;
+export function makeICAChannelAddress(hostConnectionId: IBCConnectionID, controllerConnectionId: IBCConnectionID, { version, encoding, ordering, txType, }?: ICAChannelAddressOpts): RemoteIbcAddress;
 export const DEFAULT_ICQ_VERSION: "icq-1";
 export function makeICQChannelAddress(controllerConnectionId: IBCConnectionID, version?: string): RemoteIbcAddress;
 export function findAddressField(remoteAddressString: RemoteIbcAddress): ChainAddress["value"] | undefined;
+export function getBech32Prefix(address: string): string;
 export type ICAChannelAddressOpts = {
     /**
      * message encoding format for the

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

@@ -1 +1 @@
-{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["address.js"],"names":[],"mappings":"AAwBO,wDALI,eAAe,0BACf,eAAe,iFAEb,gBAAgB,CAuB5B;AAGD,0CAA2C;AAOpC,8DAJI,eAAe,YACf,MAAM,GACJ,gBAAgB,CAQ5B;AAaM,sDAJI,gBAAgB,GAEd,YAAY,CAAC,OAAO,CAAC,GAAG,SAAS,CAY7C;;;;;;;;;;;;;;;;;;;;;qCAjFiC,cAAc;sCAEb,iCAAiC;kCADrC,aAAa"}
+{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["address.js"],"names":[],"mappings":"AAwBO,wDALI,eAAe,0BACf,eAAe,6CACf,qBAAqB,GACnB,gBAAgB,CAuB5B;AAGD,kCAAmC,OAAO,CAAC;AAOpC,8DAJI,eAAe,YACf,MAAM,GACJ,gBAAgB,CAQ5B;AAaM,sDAJI,gBAAgB,GAEd,YAAY,CAAC,OAAO,CAAC,GAAG,SAAS,CAY7C;AAYM,yCAFI,MAAM,UAQhB;;;;;;;;;;;;;;;;;;;;;qCAnGiC,cAAc;sCAEb,iCAAiC;kCADrC,aAAa"}

package/src/utils/address.js

@@ -1,4 +1,4 @@
-import { Fail } from '@endo/errors';
+import { Fail, q } from '@endo/errors';
 
 /**
  * @import {IBCConnectionID} from '@agoric/vats';
@@ -84,3 +84,20 @@ export const findAddressField = remoteAddressString => {
   }
 };
 harden(findAddressField);
+
+/**
+ * Extracts the human readable part (HRP), aka `bech32Prefix`, from an address.
+ *
+ * see
+ * [bech32.js](https://github.com/bitcoinjs/bech32/blob/5ceb0e3d4625561a459c85643ca6947739b2d83c/src/index.ts#L146)
+ * for reference implementation
+ *
+ * @param {string} address
+ */
+export const getBech32Prefix = address => {
+  assert(address, 'address is required');
+  const split = address.lastIndexOf('1');
+  if (split === -1) return Fail`No separator character for ${q(address)}`;
+  if (split === 0) return Fail`Missing prefix for ${q(address)}`;
+  return address.slice(0, split);
+};

package/src/utils/asset.d.ts

@@ -0,0 +1,5 @@
+export function assetOn(baseDenom: Denom, baseName: string, brand?: Brand<"nat">, chainName?: string, infoOf?: Record<string, CosmosChainInfo>): [string, DenomDetail];
+import type { Denom } from '../types.js';
+import type { CosmosChainInfo } from '../types.js';
+import type { DenomDetail } from '../types.js';
+//# sourceMappingURL=asset.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"asset.d.ts","sourceRoot":"","sources":["asset.js"],"names":[],"mappings":"AAiBO,mCAPI,KAAK,YACL,MAAM,UACN,KAAK,CAAC,KAAK,CAAC,cACZ,MAAM,WACN,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GAC7B,CAAC,MAAM,EAAE,WAAW,CAAC,CAiBjC;2BA7B+D,aAAa;qCAAb,aAAa;iCAAb,aAAa"}

package/src/utils/asset.js

@@ -0,0 +1,33 @@
+import { denomHash } from './denomHash.js';
+
+/**
+ * @import {ChainHub, CosmosChainInfo, Denom, DenomDetail} from '../types.js';
+ */
+
+/**
+ * Helper function for creating {@link DenomDetail} data for {@link ChainHub}
+ * asset registration.
+ *
+ * @param {Denom} baseDenom
+ * @param {string} baseName
+ * @param {Brand<'nat'>} [brand]
+ * @param {string} [chainName]
+ * @param {Record<string, CosmosChainInfo>} [infoOf]
+ * @returns {[string, DenomDetail]}
+ */
+export const assetOn = (baseDenom, baseName, brand, chainName, infoOf) => {
+  const baseDetail = { baseName, chainName: chainName || baseName, baseDenom };
+  const detail = brand ? { ...baseDetail, brand } : baseDetail;
+  if (!chainName) return harden([baseDenom, detail]);
+
+  if (!infoOf) throw Error(`must provide infoOf`);
+  const issuerInfo = infoOf[baseName];
+  const holdingInfo = infoOf[chainName];
+  if (!holdingInfo) throw Error(`${chainName} missing`);
+  if (!holdingInfo.connections)
+    throw Error(`connections missing for ${chainName}`);
+  const { channelId } =
+    holdingInfo.connections[issuerInfo.chainId].transferChannel;
+  const denom = `ibc/${denomHash({ denom: baseDenom, channelId })}`;
+  return harden([denom, detail]);
+};

package/src/utils/chain-hub-helper.d.ts

@@ -0,0 +1,8 @@
+export function registerChainsAndAssets(chainHub: ChainHub, brands: Record<string, Brand<"nat">>, chainInfo: Record<string, CosmosChainInfo> | undefined, assetInfo: [Denom, DenomDetail & {
+    brandKey?: string;
+}][] | undefined): void;
+import type { ChainHub } from '../types.js';
+import type { CosmosChainInfo } from '../types.js';
+import type { Denom } from '../types.js';
+import type { DenomDetail } from '../types.js';
+//# sourceMappingURL=chain-hub-helper.d.ts.map

package/src/utils/chain-hub-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain-hub-helper.d.ts","sourceRoot":"","sources":["chain-hub-helper.js"],"names":[],"mappings":"AAgBO,kDALI,QAAQ,UACR,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,aAC5B,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GAAG,SAAS,aAC3C,CAAC,KAAK,EAAE,WAAW,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,EAAE,GAAG,SAAS,QA6CpE;8BA1D+D,aAAa;qCAAb,aAAa;2BAAb,aAAa;iCAAb,aAAa"}

package/src/utils/chain-hub-helper.js

@@ -0,0 +1,60 @@
+/**
+ * @import {ChainHub, CosmosChainInfo, Denom, DenomDetail} from '../types.js';
+ */
+
+/**
+ * Registers chains, connections, assets in the provided chainHub.
+ *
+ * If either is not provided, registration will be skipped.
+ *
+ * TODO #10580 remove 'brandKey' in favor of `LegibleCapData`
+ *
+ * @param {ChainHub} chainHub
+ * @param {Record<string, Brand<'nat'>>} brands
+ * @param {Record<string, CosmosChainInfo> | undefined} chainInfo
+ * @param {[Denom, DenomDetail & { brandKey?: string }][] | undefined} assetInfo
+ */
+export const registerChainsAndAssets = (
+  chainHub,
+  brands,
+  chainInfo,
+  assetInfo,
+) => {
+  console.log('chainHub: registering chains', Object.keys(chainInfo || {}));
+  if (!chainInfo) {
+    return;
+  }
+
+  const conns = {};
+  for (const [chainName, allInfo] of Object.entries(chainInfo)) {
+    const { connections, ...info } = allInfo;
+    chainHub.registerChain(chainName, info);
+    if (connections) conns[info.chainId] = connections;
+  }
+  const registeredPairs = new Set();
+  for (const [pChainId, connInfos] of Object.entries(conns)) {
+    for (const [cChainId, connInfo] of Object.entries(connInfos)) {
+      const pair = [pChainId, cChainId].sort().join('<->');
+      if (!registeredPairs.has(pair)) {
+        chainHub.registerConnection(pChainId, cChainId, connInfo);
+        registeredPairs.add(pair);
+      }
+    }
+  }
+  console.log('chainHub: registered connections', [...registeredPairs].sort());
+
+  console.log(
+    'chainHub: registering assets',
+    assetInfo?.map(([denom, { chainName }]) => `${chainName}: ${denom}`),
+  );
+  if (!assetInfo) {
+    return;
+  }
+  for (const [denom, info] of assetInfo) {
+    const { brandKey, ...rest } = info;
+    const infoWithBrand = brandKey
+      ? { ...rest, brand: brands[brandKey] }
+      : rest;
+    chainHub.registerAsset(denom, infoWithBrand);
+  }
+};

package/src/utils/orchestrationAccount.js

@@ -10,11 +10,11 @@ import {
   IBCTransferOptionsShape,
 } from '../typeGuards.js';
 
-/** @import {OrchestrationAccountI} from '../orchestration-api.js'; */
+/** @import {OrchestrationAccountCommon} from '../orchestration-api.js'; */
 
 const { Vow$ } = NetworkShape; // TODO #9611
 
-/** @see {OrchestrationAccountI} */
+/** @see {OrchestrationAccountCommon} */
 export const orchestrationAccountMethods = {
   getAddress: M.call().returns(ChainAddressShape),
   getBalance: M.call(M.or(BrandShape, M.string())).returns(

package/src/utils/packet.d.ts

@@ -13,7 +13,7 @@
  * @returns {string} stringified InterchainAccountPacketData
  * @throws {Error} if malformed messages are provided
  */
-export function makeTxPacket(msgs: AnyJson[], opts?: Partial<Omit<TxBody, "messages">> | undefined): string;
+export function makeTxPacket(msgs: AnyJson[], opts?: Partial<Omit<TxBody, "messages">>): 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

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

@@ -1 +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"}
+{"version":3,"file":"packet.d.ts","sourceRoot":"","sources":["packet.js"],"names":[],"mappings":"AAcA;;;;GAIG;AAEH;;;;;;;;;GASG;AACH,mCALW,OAAO,EAAE,SACT,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,GAC/B,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/registry.d.ts

@@ -1,8 +1,10 @@
 export function convertChainInfo(registry: Pick<ChainRegistryClient, "chains" | "ibcData">): Promise<{
     [k: string]: Readonly<{
+        bech32Prefix?: string;
         chainId: string;
         connections?: Record<string, IBCConnectionInfo>;
         icqEnabled?: boolean;
+        pfmEnabled?: boolean;
         stakingTokens?: Readonly<Array<{
             denom: string;
         }>>;

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

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

package/src/utils/registry.js

@@ -90,6 +90,7 @@ export const convertChainInfo = async registry => {
   for (const chain of registry.chains) {
     console.log('processing info', chain.chain_name);
     chainInfo[chain.chain_name] = {
+      bech32Prefix: chain.bech32_prefix,
       chainId: chain.chain_id,
       stakingTokens: chain.staking?.staking_tokens,
       // UNTIL https://github.com/Agoric/agoric-sdk/issues/9326
@@ -117,8 +118,9 @@ export const convertChainInfo = async registry => {
     const connections = Object.fromEntries(
       ibcData
         .map(datum => toConnectionEntry(datum, name, chainInfo))
+        .filter(entry => entry.length > 0)
         // sort alphabetically for consistency
-        .sort(([a], [b]) => (a && b ? a.localeCompare(b) : 0)),
+        .sort(([a], [b]) => a.localeCompare(b)),
     );
     chainInfo[name] = { ...chainInfo[name], connections };
   }

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

@@ -5,6 +5,7 @@ export function provideOrchestration(zcf: ZCF, baggage: Baggage, remotePowers: O
             [durableName: string]: import("../orchestration-api.js").OrchestrationFlow<import("@agoric/async-flow").GuestInterface<HC>>;
         }>(guestFns: GFM, hostCtx: HC) => { [N in keyof GFM]: HostForGuest<GFM[N]>; };
     };
+    baggage: Baggage;
     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>>;
@@ -16,17 +17,19 @@ export function provideOrchestration(zcf: ZCF, baggage: Baggage, remotePowers: O
         }): import("@agoric/vow").Vow<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]>;
         registerAsset(denom: import("../orchestration-api.js").Denom, detail: DenomDetail): void;
-        getAsset(denom: import("../orchestration-api.js").Denom): DenomDetail | undefined;
+        getAsset(denom: import("../orchestration-api.js").Denom, srcChainName: string): DenomDetail | undefined;
         getDenom(brand: Brand): import("../orchestration-api.js").Denom | undefined;
+        makeChainAddress(address: string): import("../orchestration-api.js").ChainAddress;
+        makeTransferRoute(destination: import("../orchestration-api.js").ChainAddress, denomAmount: import("../orchestration-api.js").DenomAmount, srcChainName: string, forwardOpts?: import("../cosmos-api.js").IBCMsgTransferOptions["forwardOpts"]): import("../cosmos-api.js").TransferRoute;
     }>;
     vowTools: import("@agoric/vow").VowTools;
     asyncFlowTools: {
         prepareAsyncFlowKit: (zone: Zone, tag: string, guestAsyncFunc: import("@agoric/async-flow").GuestAsyncFunc, options?: {
             startEager?: boolean;
-        } | undefined) => (activationArgs: any) => import("@endo/exo").GuardedKit<{
+        }) => (activationArgs: any) => import("@endo/exo").GuardedKit<{
             flow: {
                 getFlowState(): import("@agoric/async-flow").FlowState;
-                restart(eager?: boolean | undefined): void;
+                restart(eager?: boolean): void;
                 wake(): void;
                 getOutcome(): import("@agoric/vow").Vow<any>;
                 dump(): ([op: "doFulfill", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, fulfillment: import("@endo/pass-style").Passable] | [op: "doReject", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, reason: import("@endo/pass-style").Passable] | [op: "doReturn", callIndex: number, result: import("@endo/pass-style").Passable] | [op: "doThrow", callIndex: number, problem: import("@endo/pass-style").Passable] | [op: "checkCall", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number] | [op: "checkSendOnly", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number] | [op: "checkSend", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number])[];
@@ -44,7 +47,7 @@ export function provideOrchestration(zcf: ZCF, baggage: Baggage, remotePowers: O
         }>;
         asyncFlow: <F extends import("@agoric/async-flow").GuestAsyncFunc>(zone: Zone, tag: string, guestFunc: F, options?: {
             startEager?: boolean;
-        } | undefined) => import("@agoric/async-flow").HostOf<F>;
+        }) => import("@agoric/async-flow").HostOf<F>;
         adminAsyncFlow: import("@endo/exo").Guarded<{
             getFailures(): import("@endo/patterns").CopyMap<any, import("@endo/pass-style").Passable>;
             wakeAll(): void;

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,0CANI,GAAG,WACH,OAAO,gBACP,mBAAmB,cACnB,UAAU;+BAqGR,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BhB;AA8BM,kCAdgC,EAAE,SAA3B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAE,EAGhC,EAAE,SAFM,mBAAmB,GAAG;IAC/B,UAAU,EAAE,UAAU,CAAC;CACvB,EACQ,CAAC,cACH,CACN,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,EACZ,WAAW,EAAE,EAAE,EACf,IAAI,EAAE,IAAI,EACV,KAAK,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;kCA1LU;IACR,UAAU,EAAE,OAAO,UAAU,CAAC,CAAC;IAC/B,oBAAoB,EAAE,OAAO,uBAAuB,CAAC,CAAC;IACtD,WAAW,EAAE,OAAO,WAAW,CAAC,CAAC;IACjC,YAAY,EAAE,OAAO,YAAY,CAAC,CAAC;IACnC,WAAW,EAAE,OAAO,OAAO,CAAC,CAAC;CAC9B;iCAgJU,IAAI,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,EAAE,MAAM,CAAC;6BA9JzC,kBAAkB;0BAGrB,cAAc;gCALR,gCAAgC;4BAIpC,aAAa;6CAEI,2BAA2B;kCAL1B,cAAc;6BAE/B,cAAc"}
+{"version":3,"file":"start-helper.d.ts","sourceRoot":"","sources":["start-helper.js"],"names":[],"mappings":"AA8CO,0CANI,GAAG,WACH,OAAO,gBACP,mBAAmB,cACnB,UAAU;+BAiGR,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;sBA/BS,CAAC;;;;;;;;;;;;;;;;;;;;;sBA0G09Y,CAAC;;;;;;;;;;;;;;;;;;;;EAzCr/Y;AA8BM,kCAdgC,EAAE,SAA3B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAE,EAGhC,EAAE,SAFM,mBAAmB,GAAG;IAC/B,UAAU,EAAE,UAAU,CAAC;CACvB,EACQ,CAAC,cACH,CACN,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,EACZ,WAAW,EAAE,EAAE,EACf,IAAI,EAAE,IAAI,EACV,KAAK,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;kCA5LU;IACR,UAAU,EAAE,OAAO,UAAU,CAAC,CAAC;IAC/B,oBAAoB,EAAE,OAAO,uBAAuB,CAAC,CAAC;IACtD,WAAW,EAAE,OAAO,WAAW,CAAC,CAAC;IACjC,YAAY,EAAE,OAAO,YAAY,CAAC,CAAC;IACnC,WAAW,EAAE,OAAO,OAAO,CAAC,CAAC;CAC9B;iCAkJU,IAAI,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,EAAE,MAAM,CAAC;6BAhKzC,kBAAkB;0BAGrB,cAAc;gCALR,gCAAgC;4BAIpC,aAAa;6CAEI,2BAA2B;kCAL1B,cAAc;6BAE/B,cAAc"}

package/src/utils/start-helper.js

@@ -50,10 +50,6 @@ export const provideOrchestration = (
   remotePowers,
   marshaller,
 ) => {
-  zcf.setTestJig(() => ({
-    baggage,
-  }));
-
   // separate zones
   const zones = (() => {
     const zone = makeDurableZone(baggage);
@@ -160,9 +156,15 @@ export const provideOrchestration = (
     zones.contract.subZone('orchestration'),
   );
 
+  zcf.setTestJig(() => ({
+    baggage,
+    chainHub,
+  }));
+
   return {
     ...defaultOrchestrateKit,
     makeOrchestrateKit,
+    baggage,
     chainHub,
     vowTools,
     asyncFlowTools,

package/src/utils/time.d.ts

@@ -15,7 +15,7 @@ export function makeTimestampHelper(timer: Remote<TimerService>): {
      * @returns {Promise<bigint>} Timeout timestamp in absolute nanoseconds
      *   since unix epoch
      */
-    getTimeoutTimestampNS(relativeTime?: RelativeTimeRecord | undefined): Promise<bigint>;
+    getTimeoutTimestampNS(relativeTime?: RelativeTimeRecord): Promise<bigint>;
 };
 /**
  * @import {RelativeTimeRecord, TimerBrand, TimerService} from '@agoric/time';

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

@@ -1 +1 @@
-{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["time.js"],"names":[],"mappings":"AAaA;;;;GAIG;AACH,2CAFW,OAAO,YAAY,CAAC;IAI3B;;;;;;;;;;OAUG;0EAFU,OAAO,CAAC,MAAM,CAAC;EAiB/B;AA1CD;;;GAGG;AAEH,qCAAsC;AACtC,4CAA6C;AAC7C,mDAAsD;AACtD,iDAAqD;8BAoCvC,OAAO,CAAC,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;kCA3CE,cAAc;4BACpD,kBAAkB;wCADoB,cAAc"}
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["time.js"],"names":[],"mappings":"AAaA;;;;GAIG;AACH,2CAFW,OAAO,YAAY,CAAC;IAI3B;;;;;;;;;;OAUG;yCAHQ,kBAAkB,GAChB,OAAO,CAAC,MAAM,CAAC;EAiB/B;AA1CD;;;GAGG;AAEH,iCAAkC,GAAG,CAAC;AACtC,sCAAuC,KAAK,CAAC;AAC7C,0CAA2C,QAAU,CAAC;AACtD,qCAAsC,WAAc,CAAC;8BAoCvC,OAAO,CAAC,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;kCA3CE,cAAc;4BACpD,kBAAkB;wCADoB,cAAc"}

package/src/vat-orchestration.d.ts

@@ -1,19 +1,19 @@
 export function buildRootObject(vatPowers: VatPowers & {
     D: DProxy;
 }, vatParameters: never, baggage: Baggage): {
-    /** @param {Partial<OrchestrationPowers>} [initialPowers] */
-    makeCosmosInterchainService(initialPowers?: Partial<OrchestrationPowers> | undefined): import("@endo/exo").Guarded<{
-        makeAccount(chainId: string, hostConnectionId: import("@agoric/vats").IBCConnectionID, controllerConnectionId: import("@agoric/vats").IBCConnectionID, opts?: import("./utils/address.js").ICAChannelAddressOpts | undefined): import("@agoric/vow").Vow<import("./cosmos-api.js").IcaAccount>;
-        provideICQConnection(controllerConnectionId: import("@agoric/vats").IBCConnectionID, version?: string | undefined): import("@agoric/vow").Vow<import("./types.js").ICQConnection> | import("./types.js").ICQConnection;
+    /** @param {Partial<CosmosOrchestrationPowers>} [initialPowers] */
+    makeCosmosInterchainService(initialPowers?: Partial<CosmosOrchestrationPowers>): import("@endo/exo").Guarded<{
+        makeAccount(chainId: string, hostConnectionId: import("@agoric/vats").IBCConnectionID, controllerConnectionId: import("@agoric/vats").IBCConnectionID, opts?: import("./utils/address.js").ICAChannelAddressOpts): import("@agoric/vow").Vow<import("./cosmos-api.js").IcaAccount>;
+        provideICQConnection(controllerConnectionId: import("@agoric/vats").IBCConnectionID, version?: string): import("@agoric/vow").Vow<import("./types.js").ICQConnection> | import("./types.js").ICQConnection;
     }>;
 } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
-    /** @param {Partial<OrchestrationPowers>} [initialPowers] */
-    makeCosmosInterchainService(initialPowers?: Partial<OrchestrationPowers> | undefined): import("@endo/exo").Guarded<{
-        makeAccount(chainId: string, hostConnectionId: import("@agoric/vats").IBCConnectionID, controllerConnectionId: import("@agoric/vats").IBCConnectionID, opts?: import("./utils/address.js").ICAChannelAddressOpts | undefined): import("@agoric/vow").Vow<import("./cosmos-api.js").IcaAccount>;
-        provideICQConnection(controllerConnectionId: import("@agoric/vats").IBCConnectionID, version?: string | undefined): import("@agoric/vow").Vow<import("./types.js").ICQConnection> | import("./types.js").ICQConnection;
+    /** @param {Partial<CosmosOrchestrationPowers>} [initialPowers] */
+    makeCosmosInterchainService(initialPowers?: Partial<CosmosOrchestrationPowers>): import("@endo/exo").Guarded<{
+        makeAccount(chainId: string, hostConnectionId: import("@agoric/vats").IBCConnectionID, controllerConnectionId: import("@agoric/vats").IBCConnectionID, opts?: import("./utils/address.js").ICAChannelAddressOpts): import("@agoric/vow").Vow<import("./cosmos-api.js").IcaAccount>;
+        provideICQConnection(controllerConnectionId: import("@agoric/vats").IBCConnectionID, version?: string): import("@agoric/vow").Vow<import("./types.js").ICQConnection> | import("./types.js").ICQConnection;
     }>;
 }>;
 export type OrchestrationVat = ReturnType<typeof buildRootObject>;
 import type { Baggage } from '@agoric/vat-data';
-import type { OrchestrationPowers } from './exos/cosmos-interchain-service.js';
+import type { CosmosOrchestrationPowers } from './exos/cosmos-interchain-service.js';
 //# sourceMappingURL=vat-orchestration.d.ts.map

package/src/vat-orchestration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vat-orchestration.d.ts","sourceRoot":"","sources":["vat-orchestration.js"],"names":[],"mappings":"AAmBO,2CANI,SAAS,GAAG;IAClB,CAAC,EAAE,MAAM,CAAC;CACX,iBACO,KAAK,WACL,OAAO;IAWd,4DAA4D;;;;;;IAA5D,4DAA4D;;;;;GAK/D;+BAEa,UAAU,CAAC,OAAO,eAAe,CAAC;6BA7BtB,kBAAkB;yCACN,qCAAqC"}
+{"version":3,"file":"vat-orchestration.d.ts","sourceRoot":"","sources":["vat-orchestration.js"],"names":[],"mappings":"AAmBO,2CANI,SAAS,GAAG;IAClB,CAAC,EAAE,MAAM,CAAC;CACX,iBACO,KAAK,WACL,OAAO;IAWd,kEAAkE;gDAAtD,OAAO,CAAC,yBAAyB,CAAC;;;;;IAA9C,kEAAkE;gDAAtD,OAAO,CAAC,yBAAyB,CAAC;;;;GAKjD;+BAEa,UAAU,CAAC,OAAO,eAAe,CAAC;6BA7BtB,kBAAkB;+CACA,qCAAqC"}

package/src/vat-orchestration.js

@@ -5,7 +5,7 @@ import { prepareCosmosInterchainService } from './exos/cosmos-interchain-service
 
 /**
  * @import {Baggage} from '@agoric/vat-data';
- * @import {OrchestrationPowers} from './exos/cosmos-interchain-service.js';
+ * @import {CosmosOrchestrationPowers} from './exos/cosmos-interchain-service.js';
  */
 
 /**
@@ -26,7 +26,7 @@ export const buildRootObject = (vatPowers, vatParameters, baggage) => {
   );
 
   return Far('OrchestrationVat', {
-    /** @param {Partial<OrchestrationPowers>} [initialPowers] */
+    /** @param {Partial<CosmosOrchestrationPowers>} [initialPowers] */
     makeCosmosInterchainService(initialPowers = {}) {
       return makeCosmosInterchainService(initialPowers);
     },