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

package/src/proposals/start-basic-flows.js

@@ -6,6 +6,7 @@ import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
 import { E } from '@endo/far';
 
 /**
+ * @import {CosmosChainInfo, Denom, DenomDetail} from '@agoric/orchestration';
  * @import {BasicFlowsSF} from '../examples/basic-flows.contract.js';
  */
 
@@ -15,30 +16,59 @@ const contractName = 'basicFlows';
 /**
  * See `@agoric/builders/builders/scripts/orchestration/init-basic-flows.js` for
  * the accompanying proposal builder. Run `agoric run
- * packages/builders/scripts/orchestration/init-basic-flows.js` to build the
+ * packages/builders/scripts/orchestration/init-basic-flows.js --chainInfo
+ * 'chainName:CosmosChainInfo' --assetInfo 'denom:DenomDetail'` to build the
  * contract and proposal files.
  *
- * @param {BootstrapPowers} powers
+ * @param {BootstrapPowers & {
+ *   installation: {
+ *     consume: {
+ *       basicFlows: Installation<BasicFlowsSF>;
+ *     };
+ *   };
+ *   instance: {
+ *     produce: {
+ *       basicFlows: Producer<Instance>;
+ *     };
+ *   };
+ *   issuer: {
+ *     consume: {
+ *       BLD: Issuer<'nat'>;
+ *       IST: Issuer<'nat'>;
+ *       USDC: Issuer<'nat'>;
+ *     };
+ *   };
+ * }} powers
+ * @param {{
+ *   options: {
+ *     chainInfo: Record<string, CosmosChainInfo>;
+ *     assetInfo: [Denom, DenomDetail & { brandKey?: string }][];
+ *   };
+ * }} config
  */
-export const startBasicFlows = async ({
-  consume: {
-    agoricNames,
-    board,
-    chainStorage,
-    chainTimerService,
-    cosmosInterchainService,
-    localchain,
-    startUpgradable,
-  },
-  installation: {
-    // @ts-expect-error not a WellKnownName
-    consume: { [contractName]: installation },
-  },
-  instance: {
-    // @ts-expect-error not a WellKnownName
-    produce: { [contractName]: produceInstance },
+export const startBasicFlows = async (
+  {
+    consume: {
+      agoricNames,
+      board,
+      chainStorage,
+      chainTimerService,
+      cosmosInterchainService,
+      localchain,
+      startUpgradable,
+    },
+    installation: {
+      consume: { [contractName]: installation },
+    },
+    instance: {
+      produce: { [contractName]: produceInstance },
+    },
+    issuer: {
+      consume: { BLD, IST },
+    },
   },
-}) => {
+  { options: { chainInfo, assetInfo } },
+) => {
   trace(`start ${contractName}`);
   await null;
 
@@ -49,6 +79,10 @@ export const startBasicFlows = async ({
   const startOpts = {
     label: 'basicFlows',
     installation,
+    issuerKeywordRecord: {
+      BLD: await BLD,
+      IST: await IST,
+    },
     terms: undefined,
     privateArgs: {
       agoricNames: await agoricNames,
@@ -57,6 +91,8 @@ export const startBasicFlows = async ({
       storageNode,
       marshaller,
       timerService: await chainTimerService,
+      chainInfo,
+      assetInfo,
     },
   };
 
@@ -67,7 +103,7 @@ harden(startBasicFlows);
 
 export const getManifestForContract = (
   { restoreRef },
-  { installKeys, ...options },
+  { installKeys, options },
 ) => {
   return {
     manifest: {
@@ -87,6 +123,9 @@ export const getManifestForContract = (
         instance: {
           produce: { [contractName]: true },
         },
+        issuer: {
+          consume: { BLD: true, IST: true },
+        },
       },
     },
     installations: {

package/src/proposals/start-send-anywhere.d.ts

@@ -0,0 +1,105 @@
+export function startSendAnywhere({ consume: { agoricNames, board, chainStorage, chainTimerService, cosmosInterchainService, localchain, startUpgradable, }, installation: { consume: { sendAnywhere }, }, instance: { produce: { sendAnywhere: produceInstance }, }, issuer: { consume: { BLD, IST }, }, }: BootstrapPowers & {
+    installation: {
+        consume: {
+            sendAnywhere: Installation<(zcf: ZCF<Record<string, unknown>>, privateArgs: import("@agoric/orchestration").OrchestrationPowers & {
+                marshaller: Marshaller;
+                chainInfo?: Record<string, Readonly<{
+                    bech32Prefix?: string;
+                    chainId: string;
+                    connections?: Record<string, import("@agoric/orchestration").IBCConnectionInfo>;
+                    icqEnabled?: boolean;
+                    pfmEnabled?: boolean;
+                    stakingTokens?: Readonly<Array<{
+                        denom: string;
+                    }>>;
+                }>>;
+                assetInfo?: [Denom, DenomDetail & {
+                    brandKey?: string;
+                }][];
+            }, baggage: import("@agoric/vat-data").Baggage) => Promise<{
+                publicFacet: import("@endo/exo").Guarded<{
+                    makeSendInvitation(): Promise<Invitation<import("@agoric/vow").Vow<void>, {
+                        chainName: string;
+                        destAddr: string;
+                    }>>;
+                }>;
+                creatorFacet: import("@endo/exo").Guarded<{
+                    registerChain(chainName: string, chainInfo: Readonly<{
+                        bech32Prefix?: string;
+                        chainId: string;
+                        connections?: Record<string, import("@agoric/orchestration").IBCConnectionInfo>;
+                        icqEnabled?: boolean;
+                        pfmEnabled?: boolean;
+                        stakingTokens?: Readonly<Array<{
+                            denom: string;
+                        }>>;
+                    }>, connectionInfo: import("@agoric/orchestration").IBCConnectionInfo): Promise<void>;
+                    registerAsset(denom: Denom, detail: DenomDetail): Promise<void>;
+                }>;
+            }>>;
+        };
+    };
+    instance: {
+        produce: {
+            sendAnywhere: Producer<Instance>;
+        };
+    };
+    issuer: {
+        consume: {
+            BLD: Issuer<"nat">;
+            IST: Issuer<"nat">;
+        };
+    };
+}, { options: { chainInfo, assetInfo } }: {
+    options: {
+        chainInfo: Record<string, CosmosChainInfo>;
+        assetInfo: [Denom, DenomDetail & {
+            brandKey?: string;
+        }][];
+    };
+}): Promise<void>;
+export function getManifest({ restoreRef }: {
+    restoreRef: any;
+}, { installationRef, options }: {
+    installationRef: any;
+    options: any;
+}): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                agoricNames: boolean;
+                board: boolean;
+                chainStorage: boolean;
+                chainTimerService: boolean;
+                cosmosInterchainService: boolean;
+                localchain: boolean;
+                startUpgradable: boolean;
+            };
+            installation: {
+                consume: {
+                    sendAnywhere: boolean;
+                };
+            };
+            instance: {
+                produce: {
+                    sendAnywhere: boolean;
+                };
+            };
+            issuer: {
+                consume: {
+                    BLD: boolean;
+                    IST: boolean;
+                };
+            };
+        };
+    };
+    installations: {
+        sendAnywhere: any;
+    };
+    options: any;
+};
+import type { Denom } from '@agoric/orchestration';
+import type { DenomDetail } from '@agoric/orchestration';
+import type { Installation } from '@agoric/zoe/src/zoeService/utils.js';
+import type { CosmosChainInfo } from '@agoric/orchestration';
+//# sourceMappingURL=start-send-anywhere.d.ts.map

package/src/proposals/start-send-anywhere.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start-send-anywhere.d.ts","sourceRoot":"","sources":["start-send-anywhere.js"],"names":[],"mappings":"AA2CO,6SAzBI,eAAe,GAAG;IACxB,YAAY,EAAE;QACZ,OAAO,EAAE;YACP,YAAY,EAAE;;;;;;;;;;;;;4BA6BM,CAAC;;;;;;;;;;;;;;;;;;;;;;eA7Bc,CAAC;SACrC,CAAC;KACH,CAAC;IACF,QAAQ,EAAE;QACR,OAAO,EAAE;YACP,YAAY,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;SAClC,CAAC;KACH,CAAC;IACF,MAAM,EAAE;QACN,OAAO,EAAE;YACP,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;YACnB,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;SACpB,CAAC;KACH,CAAC;CACH,yCACO;IACN,OAAO,EAAE;QACP,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;QAC3C,SAAS,EAAE,CAAC,KAAK,EAAE,WAAW,GAAG;YAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,EAAE,CAAC;KAC3D,CAAC;CACH,iBA2EH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BN;2BA1IqD,uBAAuB;iCAAvB,uBAAuB;kCAD9C,qCAAqC;qCACd,uBAAuB"}

package/src/proposals/start-send-anywhere.js

@@ -0,0 +1,150 @@
+import {
+  deeplyFulfilledObject,
+  makeTracer,
+  NonNullish,
+} from '@agoric/internal';
+import { E } from '@endo/far';
+
+/// <reference types="@agoric/vats/src/core/types-ambient"/>
+
+/**
+ * @import {Installation} from '@agoric/zoe/src/zoeService/utils.js';
+ * @import {CosmosChainInfo, Denom, DenomDetail} from '@agoric/orchestration';
+ * @import {start as StartFn} from '@agoric/orchestration/src/examples/send-anywhere.contract.js';
+ */
+
+const trace = makeTracer('StartSA', true);
+
+/**
+ * @param {BootstrapPowers & {
+ *   installation: {
+ *     consume: {
+ *       sendAnywhere: Installation<StartFn>;
+ *     };
+ *   };
+ *   instance: {
+ *     produce: {
+ *       sendAnywhere: Producer<Instance>;
+ *     };
+ *   };
+ *   issuer: {
+ *     consume: {
+ *       BLD: Issuer<'nat'>;
+ *       IST: Issuer<'nat'>;
+ *     };
+ *   };
+ * }} powers
+ * @param {{
+ *   options: {
+ *     chainInfo: Record<string, CosmosChainInfo>;
+ *     assetInfo: [Denom, DenomDetail & { brandKey?: string }][];
+ *   };
+ * }} config
+ */
+export const startSendAnywhere = async (
+  {
+    consume: {
+      agoricNames,
+      board,
+      chainStorage,
+      chainTimerService,
+      cosmosInterchainService,
+      localchain,
+      startUpgradable,
+    },
+    installation: {
+      consume: { sendAnywhere },
+    },
+    instance: {
+      produce: { sendAnywhere: produceInstance },
+    },
+    issuer: {
+      consume: { BLD, IST },
+    },
+  },
+  { options: { chainInfo, assetInfo } },
+) => {
+  trace(startSendAnywhere.name);
+
+  const marshaller = await E(board).getReadonlyMarshaller();
+
+  const privateArgs = await deeplyFulfilledObject(
+    harden({
+      agoricNames,
+      localchain,
+      marshaller,
+      orchestrationService: cosmosInterchainService,
+      storageNode: E(NonNullish(await chainStorage)).makeChildNode(
+        'send-anywhere',
+      ),
+      timerService: chainTimerService,
+      chainInfo,
+      assetInfo,
+    }),
+  );
+
+  /** @param {() => Promise<Issuer>} p */
+  const safeFulfill = async p =>
+    E.when(
+      p(),
+      i => i,
+      () => undefined,
+    );
+
+  const atomIssuer = await safeFulfill(() =>
+    E(agoricNames).lookup('issuer', 'ATOM'),
+  );
+  const osmoIssuer = await safeFulfill(() =>
+    E(agoricNames).lookup('issuer', 'OSMO'),
+  );
+
+  const issuerKeywordRecord = harden({
+    BLD: await BLD,
+    IST: await IST,
+    ...(atomIssuer && { ATOM: atomIssuer }),
+    ...(osmoIssuer && { OSMO: osmoIssuer }),
+  });
+  trace('issuerKeywordRecord', issuerKeywordRecord);
+
+  const { instance } = await E(startUpgradable)({
+    label: 'send-anywhere',
+    installation: sendAnywhere,
+    issuerKeywordRecord,
+    privateArgs,
+  });
+  produceInstance.resolve(instance);
+  trace('done');
+};
+harden(startSendAnywhere);
+
+export const getManifest = ({ restoreRef }, { installationRef, options }) => {
+  return {
+    manifest: {
+      [startSendAnywhere.name]: {
+        consume: {
+          agoricNames: true,
+          board: true,
+          chainStorage: true,
+          chainTimerService: true,
+          cosmosInterchainService: true,
+          localchain: true,
+
+          startUpgradable: true,
+        },
+        installation: {
+          consume: { sendAnywhere: true },
+        },
+        instance: {
+          produce: { sendAnywhere: true },
+        },
+        issuer: {
+          consume: { BLD: true, IST: true },
+        },
+      },
+    },
+    installations: {
+      sendAnywhere: restoreRef(installationRef),
+    },
+    options,
+  };
+};

package/src/proposals/start-stakeAtom.d.ts

@@ -91,6 +91,11 @@ export function startStakeAtom({ consume: { agoricNames, board, chainStorage, ch
                         }[]>;
                         getReward(validator: import("../cosmos-api.js").CosmosValidatorAddress): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount[]>;
                         getRewards(): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("../cosmos-api.js").CosmosRewardsResponse>>;
+                        executeEncodedTx(msgs: {
+                            $typeUrl?: "/google.protobuf.Any" | string | undefined;
+                            typeUrl: string;
+                            value: string;
+                        }[], opts?: Partial<Omit<import("@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js").TxBody, "messages">> | undefined): import("@agoric/vow").Vow<string>;
                     }>>;
                     makeAccountInvitationMaker(): Promise<Invitation<import("../utils/zoe-tools.js").ResolvedContinuingOfferResult, undefined>>;
                 }>;

package/src/proposals/start-stakeAtom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"start-stakeAtom.d.ts","sourceRoot":"","sources":["start-stakeAtom.js"],"names":[],"mappings":"AAyBO,0PAVI,eAAe,GAAG;IACxB,YAAY,EAAE;QACZ,OAAO,EAAE;YACP,QAAQ,EAAE,YAAY,CAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA2D,CAClD,CAAC;SACH,CAAC;KACH,CAAC;CACH,iBA4DH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BN;mCAzG4C,gCAAgC"}
+{"version":3,"file":"start-stakeAtom.d.ts","sourceRoot":"","sources":["start-stakeAtom.js"],"names":[],"mappings":"AAyBO,0PAVI,eAAe,GAAG;IACxB,YAAY,EAAE;QACZ,OAAO,EAAE;YACP,QAAQ,EAAE,YAAY,CAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA2D,CAClD,CAAC;SACH,CAAC;KACH,CAAC;CACH,iBA4DH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BN;mCAzG4C,gCAAgC"}

package/src/proposals/start-stakeBld.d.ts

@@ -17,7 +17,7 @@ export function startStakeBld({ consume: { agoricNames: agoricNamesP, board, cha
                         getPublicTopics(): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<Record<string, import("@agoric/zoe/src/contractSupport/topics.js").ResolvedPublicTopic<unknown>>>>;
                         delegate(validatorAddress: string, ertpAmount: Amount<"nat">): import("@agoric/vow").Vow<Record<unknown, unknown>>;
                         undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): import("@agoric/vow").Vow<void | import("@agoric/time").TimestampRecord>;
-                        deposit(payment: globalThis.Payment<"nat">): import("@agoric/vow").Vow<void>;
+                        deposit(payment: globalThis.Payment<"nat">): import("@agoric/vow").Vow<import("@agoric/ertp").NatAmount>;
                         withdraw(amount: import("@agoric/ertp").NatAmount): import("@agoric/vow").Vow<globalThis.Payment<"nat">>;
                         executeTx(messages: {
                             '@type': string;
@@ -27,7 +27,7 @@ export function startStakeBld({ consume: { agoricNames: agoricNamesP, board, cha
                         getAddress(): import("../orchestration-api.js").ChainAddress;
                         send(toAccount: import("../orchestration-api.js").ChainAddress, amounts: import("../orchestration-api.js").AmountArg): import("@agoric/vow").Vow<void>;
                         sendAll(toAccount: import("../orchestration-api.js").ChainAddress, amounts: import("../orchestration-api.js").AmountArg[]): import("@agoric/vow").Vow<void>;
-                        transfer(destination: import("../orchestration-api.js").ChainAddress, amount: import("../orchestration-api.js").AmountArg, opts?: import("../cosmos-api.js").IBCMsgTransferOptions | undefined): import("@agoric/vow").Vow<any>;
+                        transfer(destination: import("../orchestration-api.js").ChainAddress, amount: import("../orchestration-api.js").AmountArg, opts?: import("../cosmos-api.js").IBCMsgTransferOptions): import("@agoric/vow").Vow<any>;
                         transferSteps(amount: import("../orchestration-api.js").AmountArg, msg: import("../orchestration-api.js").TransferMsg): import("@agoric/vow").Vow<void>;
                         sendThenWaitForAck(packetSender: import("@agoric/internal").Remote<import("../exos/packet-tools.js").PacketSender>, opts?: import("../exos/packet-tools.js").PacketOptions | undefined): import("@agoric/async-flow").HostInterface<import("@agoric/vow").Vow<any>>;
                         matchFirstPacket(args_0?: import("@agoric/vow").EVow<globalThis.Pattern>): import("@agoric/async-flow").HostInterface<import("@agoric/vow").Vow<{

package/src/proposals/start-stakeOsmo.d.ts

@@ -91,6 +91,11 @@ export function startStakeOsmo({ consume: { agoricNames, board, chainStorage, ch
                         }[]>;
                         getReward(validator: import("../cosmos-api.js").CosmosValidatorAddress): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount[]>;
                         getRewards(): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("../cosmos-api.js").CosmosRewardsResponse>>;
+                        executeEncodedTx(msgs: {
+                            $typeUrl?: "/google.protobuf.Any" | string | undefined;
+                            typeUrl: string;
+                            value: string;
+                        }[], opts?: Partial<Omit<import("@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js").TxBody, "messages">> | undefined): import("@agoric/vow").Vow<string>;
                     }>>;
                     makeAccountInvitationMaker(): Promise<Invitation<import("../utils/zoe-tools.js").ResolvedContinuingOfferResult, undefined>>;
                 }>;

package/src/proposals/start-stakeOsmo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"start-stakeOsmo.d.ts","sourceRoot":"","sources":["start-stakeOsmo.js"],"names":[],"mappings":"AA8BO,0PAfI,eAAe,GAAG;IACxB,YAAY,EAAE;QACZ,OAAO,EAAE;YACP,QAAQ,EAAE,YAAY,CAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA2D,CAClD,CAAC;SACH,CAAC;KACH,CAAC;IACF,QAAQ,EAAE;QACR,OAAO,EAAE;YACP,SAAS,EAAE,GAAG,CAAC;SAChB,CAAC;KACH,CAAC;CACH,iBA4DH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BN"}
+{"version":3,"file":"start-stakeOsmo.d.ts","sourceRoot":"","sources":["start-stakeOsmo.js"],"names":[],"mappings":"AA8BO,0PAfI,eAAe,GAAG;IACxB,YAAY,EAAE;QACZ,OAAO,EAAE;YACP,QAAQ,EAAE,YAAY,CAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA2D,CAClD,CAAC;SACH,CAAC;KACH,CAAC;IACF,QAAQ,EAAE;QACR,OAAO,EAAE;YACP,SAAS,EAAE,GAAG,CAAC;SAChB,CAAC;KACH,CAAC;CACH,iBA4DH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BN"}

package/src/typeGuards.d.ts

@@ -1,10 +1,11 @@
 /**
  * @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';
  */
 /**
  * Used for IBC Channel Connections that only send outgoing transactions. If
@@ -20,8 +21,6 @@ export const ChainAddressShape: TypedPattern<ChainAddress>;
 /** @type {TypedPattern<Proto3Msg>} */
 export const Proto3Shape: TypedPattern<Proto3Msg>;
 /** @internal */
-export const IBCTransferOptionsShape: import("@endo/patterns").Matcher;
-/** @internal */
 export const IBCChannelIDShape: import("@endo/patterns").Matcher;
 /** @internal */
 export const IBCChannelInfoShape: import("@endo/patterns").Matcher;
@@ -36,8 +35,12 @@ export const CosmosChainInfoShape: TypedPattern<CosmosChainInfo>;
 /** @type {TypedPattern<ChainInfo>} */
 export const ChainInfoShape: TypedPattern<ChainInfo>;
 export const DenomShape: import("@endo/patterns").Matcher;
+/** @type {TypedPattern<Coin>} */
+export const CoinShape: TypedPattern<Coin>;
 /** @type {TypedPattern<DenomInfo<any, any>>} */
 export const DenomInfoShape: TypedPattern<DenomInfo<any, any>>;
+/** @type {TypedPattern<DenomDetail>} */
+export const DenomDetailShape: TypedPattern<DenomDetail>;
 /** @type {TypedPattern<DenomAmount>} */
 export const DenomAmountShape: TypedPattern<DenomAmount>;
 /** @type {TypedPattern<Amount<'nat'>>} */
@@ -77,15 +80,35 @@ export const TxBodyOptsShape: import("@endo/patterns").Matcher;
  * permits Nat (fungible) amounts.
  */
 export const AnyNatAmountsRecord: import("@endo/patterns").Matcher;
+/** @type {TypedPattern<OrchestrationPowers>} */
+export const OrchestrationPowersShape: TypedPattern<OrchestrationPowers>;
+/** @type {TypedPattern<ForwardInfo>} */
+export const ForwardInfoShape: TypedPattern<ForwardInfo>;
+/**
+ * Caller configurable values of {@link ForwardInfo}
+ *
+ * @type {TypedPattern<IBCMsgTransferOptions['forwardOpts']>}
+ */
+export const ForwardOptsShape: TypedPattern<IBCMsgTransferOptions["forwardOpts"]>;
+/**
+ * @type {TypedPattern<IBCMsgTransferOptions>}
+ * @internal
+ */
+export const IBCTransferOptionsShape: TypedPattern<IBCMsgTransferOptions>;
 import type { ChainAddress } from './types.js';
 import type { TypedPattern } from '@agoric/internal';
 import type { Any as Proto3Msg } from '@agoric/cosmic-proto/google/protobuf/any.js';
 import type { CosmosAssetInfo } from './types.js';
 import type { CosmosChainInfo } from './types.js';
 import type { ChainInfo } from './types.js';
+import type { Coin } from '@agoric/cosmic-proto/cosmos/base/v1beta1/coin.js';
 import type { DenomInfo } from './types.js';
+import type { DenomDetail } from './exos/chain-hub.js';
 import type { DenomAmount } from './types.js';
 import type { AmountArg } from './types.js';
 import type { CosmosValidatorAddress } from './types.js';
 import type { TypedJson } from '@agoric/cosmic-proto';
+import type { OrchestrationPowers } from './types.js';
+import type { ForwardInfo } from './types.js';
+import type { IBCMsgTransferOptions } from './types.js';
 //# sourceMappingURL=typeGuards.d.ts.map

package/src/typeGuards.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AAEH;;;;GAIG;AACH;;;GAQE;AAEF,yCAAyC;AACzC,gCADW,aAAa,YAAY,CAAC,CAKnC;AAEF,sCAAsC;AACtC,0BADW,aAAa,SAAS,CAAC,CAIhC;AAEF,gBAAgB;AAChB,uEAUE;AAEF,gBAAgB;AAChB,iEAA4C;AAC5C,gBAAgB;AAChB,mEAQG;AACH,gBAAgB;AAChB,oEAA+C;AAC/C,gBAAgB;AAChB,sEASG;AAEH,4CAA4C;AAC5C,mCADW,aAAa,eAAe,CAAC,CASrC;AAEH,4CAA4C;AAC5C,mCADW,aAAa,eAAe,CAAC,CAWtC;AAEF,sCAAsC;AACtC,6BADW,aAAa,SAAS,CAAC,CAG/B;AACH,0DAAqC;AAErC,gDAAgD;AAChD,6BADW,aAAa,UAAU,GAAG,EAAE,GAAG,CAAC,CAAC,CAM1C;AAEF,wCAAwC;AACxC,+BADW,aAAa,WAAW,CAAC,CACqC;AAEzE,0CAA0C;AAC1C,gCADW,aAAa,MAAM,CAAC,KAAK,CAAC,CAAC,CAInC;AAEH,sCAAsC;AACtC,6BADW,aAAa,SAAS,CAAC,CACsC;AAExE;;;;;GAKG;AACH,8BALU,aAAa;IAClB,SAAS,EAAE,sBAAsB,CAAC;IAClC,MAAM,EAAE,SAAS,CAAC;CACnB,CAAC,CAQH;AAEF,sCAAsC;AACtC,2DAGE;AAEF,sCAAsC;AACtC,6BADW,aAAa,SAAS,CAAC,CACmC;;;;;;;;;AAiBrE;;;;GAIG;AACH,+DAQE;AAEF;;;GAGG;AACH,mEAGE;kCAxLyJ,YAAY;kCADxI,kBAAkB;sCAEd,6CAA6C;qCAD2E,YAAY;qCAAZ,YAAY;+BAAZ,YAAY;+BAAZ,YAAY;iCAAZ,YAAY;+BAAZ,YAAY;4CAAZ,YAAY;+BAI3I,sBAAsB"}
+{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AAEH;;;;GAIG;AACH;;;GAQE;AAEF,yCAAyC;AACzC,gCADW,aAAa,YAAY,CAAC,CAKnC;AAGF,sCAAsC;AACtC,0BADW,aAAa,SAAS,CAAC,CACoC;AAGtE,gBAAgB;AAChB,iEAA4C;AAE5C,gBAAgB;AAChB,mEAQG;AAEH,gBAAgB;AAChB,oEAA+C;AAE/C,gBAAgB;AAChB,sEASG;AAEH,4CAA4C;AAC5C,mCADW,aAAa,eAAe,CAAC,CASrC;AAEH,4CAA4C;AAC5C,mCADW,aAAa,eAAe,CAAC,CAatC;AAEF,sCAAsC;AACtC,6BADW,aAAa,SAAS,CAAC,CAG/B;AACH,0DAAqC;AAErC,iCAAiC;AACjC,wBADW,aAAa,IAAI,CAAC,CAK3B;AAGF,gDAAgD;AAChD,6BADW,aAAa,UAAU,GAAG,EAAE,GAAG,CAAC,CAAC,CAM1C;AAGF,wCAAwC;AACxC,+BADW,aAAa,WAAW,CAAC,CAIlC;AAGF,wCAAwC;AACxC,+BADW,aAAa,WAAW,CAAC,CACkC;AAGtE,0CAA0C;AAC1C,gCADW,aAAa,MAAM,CAAC,KAAK,CAAC,CAAC,CAIpC;AAGF,sCAAsC;AACtC,6BADW,aAAa,SAAS,CAAC,CACsC;AAExE;;;;;GAKG;AACH,8BALU,aAAa;IAClB,SAAS,EAAE,sBAAsB,CAAC;IAClC,MAAM,EAAE,SAAS,CAAC;CACnB,CAAC,CAQH;AAEF,sCAAsC;AACtC,2DAGE;AAEF,sCAAsC;AACtC,6BADW,aAAa,SAAS,CAAC,CACmC;;;;;;;;;AAmBrE;;;;GAIG;AACH,+DAQE;AAEF;;;GAGG;AACH,mEAGE;AAEF,gDAAgD;AAChD,uCADW,aAAa,mBAAmB,CAAC,CAO1C;AAYF,wCAAwC;AACxC,+BADW,aAAa,WAAW,CAAC,CAWlC;AAGF;;;;GAIG;AACH,+BAFU,aAAa,qBAAqB,CAAC,aAAa,CAAC,CAAC,CAU1D;AAEF;;;GAGG;AACH,sCAHU,aAAa,qBAAqB,CAAC,CAc3C;kCArQqM,YAAY;kCADpL,kBAAkB;sCAEd,6CAA6C;qCADuH,YAAY;qCAAZ,YAAY;+BAAZ,YAAY;0BAG5L,kDAAkD;+BAH8H,YAAY;iCAKrL,qBAAqB;iCALoJ,YAAY;+BAAZ,YAAY;4CAAZ,YAAY;+BAIvL,sBAAsB;yCAJqJ,YAAY;iCAAZ,YAAY;2CAAZ,YAAY"}