@agoric/orchestration 0.2.0-upgrade-20-dev-ef71cfd.0 → 0.2.0-upgrade-19-devnet-dev-5428c4d.0

package/src/examples/send-anywhere.flows.js

@@ -1,16 +1,13 @@
 import { NonNullish } from '@agoric/internal';
-import { Fail, makeError, q } from '@endo/errors';
+import { makeError, q } from '@endo/errors';
 import { M, mustMatch } from '@endo/patterns';
 
 /**
  * @import {GuestInterface, GuestOf} from '@agoric/async-flow';
- * @import {Invitation, ZCF, ZCFSeat} from '@agoric/zoe';
- * @import {Brand} from '@agoric/ertp';
  * @import {Vow} from '@agoric/vow';
  * @import {LocalOrchestrationAccountKit} from '../exos/local-orchestration-account.js';
  * @import {ZoeTools} from '../utils/zoe-tools.js';
- * @import {Orchestrator, OrchestrationFlow, LocalAccountMethods, ChainHub, ChainInfo} from '../types.js';
- * @import {AccountIdArg} from '../orchestration-api.ts';
+ * @import {Orchestrator, OrchestrationFlow, LocalAccountMethods} from '../types.js';
  */
 
 const { entries } = Object;
@@ -18,53 +15,19 @@ const { entries } = Object;
 // in guest file (the orchestration functions)
 // the second argument is all the endowments provided
 
-/**
- * @satisfies {OrchestrationFlow}
- * @param {Orchestrator} orch
- */
-export const makeNobleAccount = async orch => {
-  const nobleChain = await orch.getChain('noble');
-  return nobleChain.makeAccount();
-};
-harden(makeNobleAccount);
-
-const denomForBrand = async (orch, brand) => {
-  const agoric = await orch.getChain('agoric');
-  const assets = await agoric.getVBankAssetInfo();
-  const { denom } = NonNullish(
-    assets.find(a => a.brand === brand),
-    `${brand} not registered in ChainHub`,
-  );
-  return denom;
-};
-
 /**
  * @satisfies {OrchestrationFlow}
  * @param {Orchestrator} orch
  * @param {object} ctx
- * @param {GuestInterface<ChainHub>} ctx.chainHub
  * @param {Promise<GuestInterface<LocalOrchestrationAccountKit['holder']>>} ctx.sharedLocalAccountP
- * @param {Promise<
- *   GuestInterface<
- *     import('../exos/cosmos-orchestration-account.js').CosmosOrchestrationAccountKit['holder']
- *   >
- * >} ctx.nobleAccountP
  * @param {GuestInterface<ZoeTools>} ctx.zoeTools
  * @param {GuestOf<(msg: string) => Vow<void>>} ctx.log
- * @param {Brand} ctx.USDC
  * @param {ZCFSeat} seat
  * @param {{ chainName: string; destAddr: string }} offerArgs
  */
 export const sendIt = async (
   orch,
-  {
-    chainHub,
-    sharedLocalAccountP,
-    log,
-    nobleAccountP,
-    USDC,
-    zoeTools: { localTransfer, withdrawToSeat },
-  },
+  { sharedLocalAccountP, log, zoeTools: { localTransfer, withdrawToSeat } },
   seat,
   offerArgs,
 ) => {
@@ -74,89 +37,45 @@ export const sendIt = async (
   const { give } = seat.getProposal();
   const [[_kw, amt]] = entries(give);
   void log(`sending {${amt.value}} from ${chainName} to ${destAddr}`);
-  const denom = await denomForBrand(orch, amt.brand);
+  const agoric = await orch.getChain('agoric');
+  const assets = await agoric.getVBankAssetInfo();
+  void log(`got info for denoms: ${assets.map(a => a.denom).join(', ')}`);
+  const { denom } = NonNullish(
+    assets.find(a => a.brand === amt.brand),
+    `${amt.brand} not registered in vbank`,
+  );
 
-  /** @type {ChainInfo} */
-  const info = await chainHub.getChainInfo(chainName);
+  const chain = await orch.getChain(chainName);
+  const info = await chain.getChainInfo();
+  const { chainId } = info;
+  assert(typeof chainId === 'string', 'bad chainId');
+  void log(`got info for chain: ${chainName} ${chainId}`);
 
   /**
    * @type {any} XXX methods returning vows
    *   https://github.com/Agoric/agoric-sdk/issues/9822
    */
   const sharedLocalAccount = await sharedLocalAccountP;
-
-  /**
-   * Helper function to recover if IBC Transfer fails
-   *
-   * @param {Error} e
-   */
-  const recoverFailedTransfer = async e => {
+  await localTransfer(seat, sharedLocalAccount, give);
+
+  void log(`completed transfer to localAccount`);
+
+  try {
+    await sharedLocalAccount.transfer(
+      {
+        value: destAddr,
+        encoding: 'bech32',
+        chainId,
+      },
+      { denom, value: amt.value },
+    );
+    void log(`completed transfer to ${destAddr}`);
+  } catch (e) {
     await withdrawToSeat(sharedLocalAccount, seat, give);
     const errorMsg = `IBC Transfer failed ${q(e)}`;
     void log(`ERROR: ${errorMsg}`);
-    seat.fail(errorMsg);
+    seat.exit(errorMsg);
     throw makeError(errorMsg);
-  };
-
-  if (info.namespace === 'cosmos') {
-    const { chainId } = info;
-    assert(typeof chainId === 'string', 'bad chainId');
-
-    const [_a, _o, connection] = await chainHub.getChainsAndConnection(
-      'agoric',
-      chainName,
-    );
-
-    connection.counterparty || Fail`No IBC connection to ${chainName}`;
-
-    void log(`got info for chain: ${chainName} ${chainId}`);
-
-    await localTransfer(seat, sharedLocalAccount, give);
-    void log(`completed transfer to localAccount`);
-
-    try {
-      await sharedLocalAccount.transfer(
-        {
-          value: destAddr,
-          encoding: 'bech32',
-          chainId,
-        },
-        { denom, value: amt.value },
-      );
-      void log(`completed transfer to ${destAddr}`);
-    } catch (e) {
-      return recoverFailedTransfer(e);
-    }
-  } else if (amt.brand === USDC && 'cctpDestinationDomain' in info) {
-    const nobleAccount = await nobleAccountP;
-    const nobleAddr = nobleAccount.getAddress();
-    const denomAmt = { denom, value: amt.value };
-    try {
-      await sharedLocalAccount.transfer(nobleAddr, denomAmt);
-    } catch (e) {
-      return recoverFailedTransfer(e);
-    }
-    void log('assets are now on noble');
-    const destAccountId = /** @type {const} */ (
-      `${info.namespace}:${info.reference}:${destAddr}`
-    );
-    try {
-      await nobleAccount.depositForBurn(destAccountId, denomAmt);
-    } catch (e) {
-      try {
-        // transfer back to agoric contract account if depositForBurn is not accepted by noble chain
-        const lcaAddress = await sharedLocalAccount.getAddress();
-        await nobleAccount.transfer(lcaAddress, denomAmt);
-      } catch (err) {
-        const errorMsg = `IBC Transfer from Noble back to LocalAccount failed: ${q(err)}`;
-        void log(`🚨 contract upgrade required to recover funds: ${errorMsg}`);
-        seat.fail(errorMsg);
-        throw makeError(errorMsg);
-      }
-      return recoverFailedTransfer(e);
-    }
-  } else {
-    Fail`There is currently support only for IBC and USDC transfers`;
   }
 
   seat.exit();

package/src/examples/stake-bld.contract.d.ts

@@ -9,7 +9,7 @@ export function start(zcf: ZCF, privateArgs: {
         /**
          * Invitation to make an account, initialized with the give's BLD
          */
-        makeStakeBldInvitation(): Promise<globalThis.Invitation<import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("../utils/zoe-tools.js").ResolvedContinuingOfferResult>>, undefined>>;
+        makeStakeBldInvitation(): Promise<Invitation<import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("../utils/zoe-tools.js").ResolvedContinuingOfferResult>>, undefined>>;
         makeAccount(): Promise<import("@endo/exo").Guarded<{
             asContinuingOffer(): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("../utils/zoe-tools.js").ResolvedContinuingOfferResult>>;
             getBalance(denom: import("../orchestration-api.js").DenomArg): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount>;
@@ -24,13 +24,13 @@ export function start(zcf: ZCF, privateArgs: {
             }[]): import("@agoric/vow").Vow<{
                 '@type': string;
             }[]>;
-            getAddress(): import("../orchestration-api.js").CosmosChainAddress;
-            send(toAccount: import("../orchestration-api.js").AccountIdArg, amount: import("../orchestration-api.js").AmountArg): import("@agoric/vow").Vow<void>;
-            sendAll(toAccount: import("../orchestration-api.js").CosmosChainAddress, amounts: import("../orchestration-api.js").AmountArg[]): import("@agoric/vow").Vow<void>;
-            transfer(destination: import("../orchestration-api.js").AccountIdArg, amount: import("../orchestration-api.js").AmountArg, opts?: import("../cosmos-api.js").IBCMsgTransferOptions): import("@agoric/vow").Vow<any>;
+            getAddress(): import("../orchestration-api.js").ChainAddress;
+            send(toAccount: import("../orchestration-api.js").ChainAddress, amount: 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): 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: 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<Pattern>): import("@agoric/async-flow").HostInterface<import("@agoric/vow").Vow<{
+            matchFirstPacket(args_0?: import("@agoric/vow").EVow<globalThis.Pattern>): import("@agoric/async-flow").HostInterface<import("@agoric/vow").Vow<{
                 resolver: import("@agoric/vow").VowResolver<any>;
                 match: import("@agoric/vow").Vow<any>;
             }>>;
@@ -39,10 +39,9 @@ export function start(zcf: ZCF, privateArgs: {
         /**
          * Invitation to make an account, without any funds
          */
-        makeAccountInvitationMaker(): Promise<globalThis.Invitation<import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("../utils/zoe-tools.js").ResolvedContinuingOfferResult>>, undefined>>;
+        makeAccountInvitationMaker(): Promise<Invitation<import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("../utils/zoe-tools.js").ResolvedContinuingOfferResult>>, undefined>>;
     }>;
 }>;
-import type { ZCF } from '@agoric/zoe';
 import type { NameHub } from '@agoric/vats';
 import type { Remote } from '@agoric/internal';
 import type { LocalChain } from '@agoric/vats/src/localchain.js';

package/src/examples/stake-bld.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stake-bld.contract.d.ts","sourceRoot":"","sources":["stake-bld.contract.js"],"names":[],"mappings":"AAqCO,2BAVI,GAAG,eACH;IACN,WAAW,EAAE,OAAO,OAAO,CAAC,CAAC;IAC7B,UAAU,EAAE,OAAO,UAAU,CAAC,CAAC;IAC/B,UAAU,EAAE,UAAU,CAAC;IACvB,WAAW,EAAE,WAAW,CAAC;IACzB,YAAY,EAAE,YAAY,CAAC;CAC5B,WACO,OAAO,kBAAkB,EAAE,OAAO;;QAsEvC;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA6BH;;WAEG;;;GAaR;yBAlIqB,aAAa;6BAJT,cAAc;4BACf,kBAAkB;gCAEd,gCAAgC;kCAD9B,cAAc"}
+{"version":3,"file":"stake-bld.contract.d.ts","sourceRoot":"","sources":["stake-bld.contract.js"],"names":[],"mappings":"AAoCO,2BAVI,GAAG,eACH;IACN,WAAW,EAAE,OAAO,OAAO,CAAC,CAAC;IAC7B,UAAU,EAAE,OAAO,UAAU,CAAC,CAAC;IAC/B,UAAU,EAAE,UAAU,CAAC;IACvB,WAAW,EAAE,WAAW,CAAC;IACzB,YAAY,EAAE,YAAY,CAAC;CAC5B,WACO,OAAO,kBAAkB,EAAE,OAAO;;QAsEvC;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA4BH;;WAEG;;;GAaR;6BApIyB,cAAc;4BACf,kBAAkB;gCAEd,gCAAgC;kCAD9B,cAAc"}

package/src/examples/stake-bld.contract.js

@@ -19,7 +19,6 @@ import { makeZoeTools } from '../utils/zoe-tools.js';
  * @import {Remote} from '@agoric/internal';
  * @import {TimerService} from '@agoric/time';
  * @import {LocalChain} from '@agoric/vats/src/localchain.js';
- * @import {ZCF} from '@agoric/zoe';
  */
 
 const trace = makeTracer('StakeBld');
@@ -113,8 +112,7 @@ export const start = async (zcf, privateArgs, baggage) => {
             trace('makeStakeBldInvitation', give);
             const { holder } = await makeLocalAccountKit();
             /** @type {Record<string, Payment<'nat'>>} */
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment -- fails only through some build paths
-            // @ts-ignore XXX PaymentPKeywordRecord, though after deeplyFulfilled it will be a PaymentKeywordRecord
+            // @ts-expect-error XXX PaymentPKeywordRecord throught deeplyFulfilled will be a PaymnentKeywordRecord
             const { In } = await deeplyFulfilled(
               withdrawFromSeat(zcf, seat, give),
             );

package/src/examples/stake-ica.contract.d.ts

@@ -1,7 +1,6 @@
 /**
  * @import {Baggage} from '@agoric/vat-data';
  * @import {Remote} from '@agoric/internal';
- * @import {ContractMeta, Invitation, ZCF, ZCFSeat} from '@agoric/zoe';
  * @import {IBCConnectionID, NameHub} from '@agoric/vats';
  * @import {TimerService} from '@agoric/time';
  * @import {ResolvedContinuingOfferResult} from '../utils/zoe-tools.js';
@@ -10,11 +9,11 @@
 /** @type {ContractMeta<typeof start>} */
 export const meta: ContractMeta<typeof start>;
 export const privateArgsShape: {
-    agoricNames: Pattern;
-    cosmosInterchainService: Pattern;
-    storageNode: Pattern;
-    marshaller: Pattern;
-    timer: Pattern;
+    agoricNames: globalThis.Pattern;
+    cosmosInterchainService: globalThis.Pattern;
+    storageNode: globalThis.Pattern;
+    marshaller: globalThis.Pattern;
+    timer: globalThis.Pattern;
 } | undefined;
 export function start(zcf: ZCF<StakeIcaTerms>, privateArgs: {
     agoricNames: Remote<NameHub>;
@@ -27,20 +26,20 @@ export function start(zcf: ZCF<StakeIcaTerms>, privateArgs: {
         makeAccount(): Promise<import("@endo/exo").Guarded<{
             asContinuingOffer(): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<ResolvedContinuingOfferResult>>;
             getPublicTopics(): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<Record<string, import("@agoric/zoe/src/contractSupport/topics.js").ResolvedPublicTopic<unknown>>>>;
-            getAddress(): import("@agoric/async-flow").HostInterface<import("../orchestration-api.js").CosmosChainAddress>;
+            getAddress(): import("@agoric/async-flow").HostInterface<import("../orchestration-api.js").ChainAddress>;
             delegate(validator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): import("@agoric/vow").Vow<void>;
             redelegate(srcValidator: import("../cosmos-api.js").CosmosValidatorAddress, dstValidator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): import("@agoric/vow").Vow<void>;
             withdrawReward(validator: import("../cosmos-api.js").CosmosValidatorAddress): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount[]>;
             getBalance(denom: import("../orchestration-api.js").DenomArg): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount>;
             getBalances(): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount[]>;
-            send(toAccount: import("../orchestration-api.js").AccountIdArg, amount: import("../orchestration-api.js").AmountArg): import("@agoric/vow").Vow<void>;
-            sendAll(toAccount: import("../orchestration-api.js").CosmosChainAddress, amounts: import("../orchestration-api.js").AmountArg[]): import("@agoric/vow").Vow<void>;
-            transfer(destination: import("../orchestration-api.js").AccountIdArg, amount: import("../orchestration-api.js").AmountArg, opts?: import("../cosmos-api.js").IBCMsgTransferOptions | undefined): import("@agoric/vow").Vow<void>;
+            send(toAccount: import("../orchestration-api.js").ChainAddress, amount: 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<void>;
             transferSteps(amount: import("../orchestration-api.js").AmountArg, msg: import("../orchestration-api.js").TransferMsg): import("@agoric/vow").Vow<void>;
             withdrawRewards(): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount[]>;
             undelegate(delegations: {
                 amount: import("../orchestration-api.js").AmountArg;
-                delegator?: import("../orchestration-api.js").CosmosChainAddress;
+                delegator?: import("../orchestration-api.js").ChainAddress;
                 validator: import("../cosmos-api.js").CosmosValidatorAddress;
             }[]): import("@agoric/vow").Vow<void>;
             deactivate(): import("@agoric/vow").Vow<void>;
@@ -49,76 +48,12 @@ export function start(zcf: ZCF<StakeIcaTerms>, privateArgs: {
             getDelegations(): import("@agoric/vow").Vow<{
                 delegator: {
                     chainId: string;
-                    value: import("../cosmos-api.js").Bech32Address;
-                    encoding: "bech32";
+                    value: string;
+                    encoding: "bech32" | "ethereum";
                 };
                 validator: {
                     chainId: string;
-                    value: {
-                        readonly [x: number]: string;
-                        toString: () => string;
-                        charAt: (pos: number) => string;
-                        charCodeAt: (index: number) => number;
-                        concat: (...args: string[]) => string;
-                        indexOf: (searchString: string, position?: number | undefined) => number;
-                        lastIndexOf: (searchString: string, position?: number | undefined) => number;
-                        localeCompare: (that: string, locales?: Intl.LocalesArgument, options?: Intl.CollatorOptions | undefined) => number;
-                        match: ((matcher: {
-                            [Symbol.match](string: string): RegExpMatchArray | null;
-                        }) => null) | ((matcher: {
-                            [Symbol.match](string: string): RegExpMatchArray | null;
-                        }) => import("@agoric/async-flow").HostInterface<RegExpMatchArray>);
-                        replace: (searchValue: {
-                            [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string;
-                        }, replacer: (substring: string, ...args: any[]) => string) => string;
-                        search: (searcher: {
-                            [Symbol.search](string: string): number;
-                        }) => number;
-                        slice: (start?: number | undefined, end?: number | undefined) => string;
-                        split: (splitter: {
-                            [Symbol.split](string: string, limit?: number): string[];
-                        }, limit?: number | undefined) => string[];
-                        substring: (start: number, end?: number | undefined) => string;
-                        toLowerCase: () => string;
-                        toLocaleLowerCase: (locales?: Intl.LocalesArgument) => string;
-                        toUpperCase: () => string;
-                        toLocaleUpperCase: (locales?: Intl.LocalesArgument) => string;
-                        trim: () => string;
-                        readonly length: number;
-                        substr: (from: number, length?: number | undefined) => string;
-                        valueOf: () => string;
-                        codePointAt: ((pos: number) => undefined) | ((pos: number) => number);
-                        includes: ((searchString: string, position?: number | undefined) => false) | ((searchString: string, position?: number | undefined) => true);
-                        endsWith: ((searchString: string, endPosition?: number | undefined) => false) | ((searchString: string, endPosition?: number | undefined) => true);
-                        normalize: (form?: string | undefined) => string;
-                        repeat: (count: number) => string;
-                        startsWith: ((searchString: string, position?: number | undefined) => false) | ((searchString: string, position?: number | undefined) => true);
-                        anchor: (name: string) => string;
-                        big: () => string;
-                        blink: () => string;
-                        bold: () => string;
-                        fixed: () => string;
-                        fontcolor: (color: string) => string;
-                        fontsize: (size: string) => string;
-                        italics: () => string;
-                        link: (url: string) => string;
-                        small: () => string;
-                        strike: () => string;
-                        sub: () => string;
-                        sup: () => string;
-                        padStart: (maxLength: number, fillString?: string | undefined) => string;
-                        padEnd: (maxLength: number, fillString?: string | undefined) => string;
-                        trimEnd: () => string;
-                        trimStart: () => string;
-                        trimLeft: () => string;
-                        trimRight: () => string;
-                        matchAll: (regexp: RegExp) => import("@agoric/async-flow").HostInterface<RegExpStringIterator<RegExpExecArray>>;
-                        replaceAll: (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string) => string;
-                        at: ((index: number) => undefined) | ((index: number) => string);
-                        isWellFormed: (() => false) | (() => true);
-                        toWellFormed: () => string;
-                        [Symbol.iterator]: () => import("@agoric/async-flow").HostInterface<StringIterator<string>>;
-                    };
+                    value: `${string}valoper${string}`;
                     encoding: "bech32";
                 };
                 amount: {
@@ -175,7 +110,6 @@ export function start(zcf: ZCF<StakeIcaTerms>, privateArgs: {
                 typeUrl: string;
                 value: string;
             }[], opts?: Partial<Omit<import("@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js").TxBody, "messages">> | undefined): import("@agoric/vow").Vow<string>;
-            depositForBurn(mintRecipient: `${string}:${string}:${string}`, amount: import("../orchestration-api.js").AmountArg, caller?: `${string}:${string}:${string}` | undefined): import("@agoric/vow").Vow<void>;
         }>>;
         makeAccountInvitationMaker(): Promise<Invitation<ResolvedContinuingOfferResult, undefined>>;
     }>;
@@ -187,14 +121,11 @@ export type StakeIcaTerms = {
     icqEnabled: boolean;
 };
 export type StakeIcaSF = typeof start;
-import type { ContractMeta } from '@agoric/zoe';
-import type { ZCF } from '@agoric/zoe';
 import type { NameHub } from '@agoric/vats';
 import type { Remote } from '@agoric/internal';
 import type { CosmosInterchainService } from '../types.js';
 import type { TimerService } from '@agoric/time';
 import type { Baggage } from '@agoric/vat-data';
 import type { ResolvedContinuingOfferResult } from '../utils/zoe-tools.js';
-import type { Invitation } from '@agoric/zoe';
 import type { IBCConnectionID } from '@agoric/vats';
 //# sourceMappingURL=stake-ica.contract.d.ts.map

package/src/examples/stake-ica.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stake-ica.contract.d.ts","sourceRoot":"","sources":["stake-ica.contract.js"],"names":[],"mappings":"AAgBA;;;;;;;;GAQG;AAEH,yCAAyC;AACzC,mBADW,aAAa,OAAO,KAAK,CAAC,CAelC;AAEH;;;;;;cAAsD;AAuB/C,2BAVI,IAAI,aAAa,CAAC,eAClB;IACN,WAAW,EAAE,OAAO,OAAO,CAAC,CAAC;IAC7B,uBAAuB,EAAE,uBAAuB,CAAC;IACjD,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,UAAU,CAAC;IACvB,KAAK,EAAE,YAAY,CAAC;CACrB,WACO,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyGjB;4BA1HY;IACR,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,eAAe,CAAC;IAClC,sBAAsB,EAAE,eAAe,CAAC;IACxC,UAAU,EAAE,OAAO,CAAC;CACrB;yBAwHU,OAAO,KAAK;kCAzJ+B,aAAa;yBAAb,aAAa;6BAC3B,cAAc;4BAFhC,kBAAkB;6CAKwB,aAAa;kCAFjD,cAAc;6BAJnB,kBAAkB;mDAKI,uBAAuB;gCAHd,aAAa;qCAC3B,cAAc"}
+{"version":3,"file":"stake-ica.contract.d.ts","sourceRoot":"","sources":["stake-ica.contract.js"],"names":[],"mappings":"AAgBA;;;;;;;GAOG;AAEH,yCAAyC;AACzC,mBADW,YAAY,CAAC,OAAO,KAAK,CAAC,CAelC;AAEH;;;;;;cAAsD;AAuB/C,2BAVI,GAAG,CAAC,aAAa,CAAC,eAClB;IACN,WAAW,EAAE,OAAO,OAAO,CAAC,CAAC;IAC7B,uBAAuB,EAAE,uBAAuB,CAAC;IACjD,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,UAAU,CAAC;IACvB,KAAK,EAAE,YAAY,CAAC;CACrB,WACO,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyGjB;4BA1HY;IACR,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,eAAe,CAAC;IAClC,sBAAsB,EAAE,eAAe,CAAC;IACxC,UAAU,EAAE,OAAO,CAAC;CACrB;yBAwHU,OAAO,KAAK;6BAxJiB,cAAc;4BADhC,kBAAkB;6CAIwB,aAAa;kCAFjD,cAAc;6BAHnB,kBAAkB;mDAII,uBAAuB;qCAF5B,cAAc"}

package/src/examples/stake-ica.contract.js

@@ -17,7 +17,6 @@ const trace = makeTracer('StakeIca');
 /**
  * @import {Baggage} from '@agoric/vat-data';
  * @import {Remote} from '@agoric/internal';
- * @import {ContractMeta, Invitation, ZCF, ZCFSeat} from '@agoric/zoe';
  * @import {IBCConnectionID, NameHub} from '@agoric/vats';
  * @import {TimerService} from '@agoric/time';
  * @import {ResolvedContinuingOfferResult} from '../utils/zoe-tools.js';

package/src/examples/staking-combinations.contract.d.ts

@@ -7,11 +7,19 @@ export const start: (zcf: ZCF<Record<string, unknown>>, privateArgs: Orchestrati
         }>>;
     }>;
     creatorFacet: import("@endo/exo").Guarded<{
-        registerChain(chainName: string, chainInfo: import("../orchestration-api.js").ChainInfo, ibcConnectionInfo?: import("../cosmos-api.js").IBCConnectionInfo): Promise<void>;
+        registerChain(chainName: string, chainInfo: Readonly<{
+            bech32Prefix?: string;
+            chainId: string;
+            connections?: Record<string, import("../cosmos-api.js").IBCConnectionInfo>;
+            icqEnabled?: boolean;
+            pfmEnabled?: boolean;
+            stakingTokens?: Readonly<Array<{
+                denom: string;
+            }>>;
+            icaEnabled?: boolean;
+        }>, connectionInfo: import("../cosmos-api.js").IBCConnectionInfo): Promise<void>;
         registerAsset(denom: import("../orchestration-api.js").Denom, detail: import("../types.js").DenomDetail): Promise<void>;
     }>;
 }>;
-import type { ZCF } from '@agoric/zoe';
 import type { OrchestrationPowers } from '../utils/start-helper.js';
-import type { Invitation } from '@agoric/zoe';
 //# sourceMappingURL=staking-combinations.contract.d.ts.map

package/src/examples/staking-combinations.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"staking-combinations.contract.d.ts","sourceRoot":"","sources":["staking-combinations.contract.js"],"names":[],"mappings":"AAkKA;gBA5HiB,UAAU;;;;;;;;;;;GA4HoD;yBA/ItB,aAAa;yCAEZ,0BAA0B;gCAF3B,aAAa"}
+{"version":3,"file":"staking-combinations.contract.d.ts","sourceRoot":"","sources":["staking-combinations.contract.js"],"names":[],"mappings":"AAiKA;gBA5HiB,UAAU;;;;;;;;;;;;;;;;;;;;;GA4HoD;yCA7IrB,0BAA0B"}

package/src/examples/staking-combinations.contract.js

@@ -9,7 +9,7 @@ import { AmountShape } from '@agoric/ertp';
 import { M } from '@endo/patterns';
 import { prepareCombineInvitationMakers } from '../exos/combine-invitation-makers.js';
 import { CosmosOrchestrationInvitationMakersI } from '../exos/cosmos-orchestration-account.js';
-import { CosmosChainAddressShape, DelegationShape } from '../typeGuards.js';
+import { ChainAddressShape, DelegationShape } from '../typeGuards.js';
 import { withOrchestration } from '../utils/start-helper.js';
 import * as flows from './staking-combinations.flows.js';
 import * as sharedFlows from './shared.flows.js';
@@ -17,11 +17,10 @@ import { prepareChainHubAdmin } from '../exos/chain-hub-admin.js';
 
 /**
  * @import {GuestInterface} from '@agoric/async-flow';
- * @import {ContractMeta, Invitation, ZCF, ZCFSeat} from '@agoric/zoe';
  * @import {Zone} from '@agoric/zone';
  * @import {OrchestrationTools, OrchestrationPowers} from '../utils/start-helper.js';
  * @import {CosmosOrchestrationAccount} from '../exos/cosmos-orchestration-account.js';
- * @import {AmountArg, CosmosChainAddress, CosmosValidatorAddress} from '../types.js';
+ * @import {AmountArg, ChainAddress, CosmosValidatorAddress} from '../types.js';
  */
 
 const emptyOfferShape = harden({
@@ -53,7 +52,7 @@ const contract = async (
       DepositAndDelegate: M.call().returns(M.promise()),
       UndelegateAndTransfer: M.call(
         M.arrayOf(DelegationShape),
-        CosmosChainAddressShape,
+        ChainAddressShape,
       ).returns(M.promise()),
     },
   );
@@ -91,7 +90,7 @@ const contract = async (
       },
       /**
        * @param {{ amount: AmountArg; validator: CosmosValidatorAddress }[]} delegations
-       * @param {CosmosChainAddress} destination
+       * @param {ChainAddress} destination
        */
       UndelegateAndTransfer(delegations, destination) {
         const { account } = this.state;

package/src/examples/staking-combinations.flows.d.ts

@@ -14,7 +14,7 @@ export function undelegateAndTransfer(orch: Orchestrator, ctx: object, account:
         amount: AmountArg;
         validator: CosmosValidatorAddress;
     }[];
-    destination: CosmosChainAddress;
+    destination: ChainAddress;
 }): Promise<void>;
 import type { Orchestrator } from '../types.js';
 import type { MakeCombineInvitationMakers } from '../exos/combine-invitation-makers.js';
@@ -27,5 +27,5 @@ import type { ZoeTools } from '../utils/zoe-tools.js';
 import type { CosmosOrchestrationAccount } from '../exos/cosmos-orchestration-account.js';
 import type { CosmosValidatorAddress } from '../types.js';
 import type { AmountArg } from '../types.js';
-import type { CosmosChainAddress } from '../types.js';
+import type { ChainAddress } from '../types.js';
 //# sourceMappingURL=staking-combinations.flows.d.ts.map

package/src/examples/staking-combinations.flows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"staking-combinations.flows.d.ts","sourceRoot":"","sources":["staking-combinations.flows.js"],"names":[],"mappings":"AA4BO,kCATI,YAAY,OACZ;IACN,2BAA2B,EAAE,2BAA2B,CAAC;IACzD,wBAAwB,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,gBAAgB,CAAC;CAC9D,SACO,OAAO,iBACP;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,GACnB,OAAO,CAAC,6BAA6B,CAAC,CAiBlD;AAeM,yCAVI,YAAY,+CAEpB;IAAsC,QAAQ,EAAtC,eAAe,QAAQ,CAAC;IAC6C,mBAAmB,EAAxF,OAAO,CAAC,eAAe,4BAA4B,CAAC,QAAQ,CAAC,CAAC,CAAC;IACjC,QAAQ,EAAtC,eAAe,QAAQ,CAAC;CAChC,WAAQ,eAAe,0BAA0B,CAAC,QAC1C,OAAO,aACP,sBAAsB,GACpB,OAAO,CAAC,IAAI,CAAC,CAoCzB;AAcM,4CATI,YAAY,OACZ,MAAM,WACN,eAAe,0BAA0B,CAAC,gCAC1C;IACN,WAAW,EAAE;QAAE,MAAM,EAAE,SAAS,CAAC;QAAC,SAAS,EAAE,sBAAsB,CAAA;KAAE,EAAE,CAAC;IACxE,WAAW,EAAE,kBAAkB,CAAC;CACjC,GACS,OAAO,CAAC,IAAI,CAAC,CAYzB;kCAlHmK,aAAa;iDAGnI,sCAAsC;sCAF1B,mCAAmC;mDAInC,uBAAuB;8BALmF,aAAa;oCADhJ,oBAAoB;kDAGN,wCAAwC;8BAG7B,uBAAuB;gDADpC,yCAAyC;4CAJ8E,aAAa;+BAAb,aAAa;wCAAb,aAAa"}
+{"version":3,"file":"staking-combinations.flows.d.ts","sourceRoot":"","sources":["staking-combinations.flows.js"],"names":[],"mappings":"AA4BO,kCATI,YAAY,OACZ;IACN,2BAA2B,EAAE,2BAA2B,CAAC;IACzD,wBAAwB,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,gBAAgB,CAAC;CAC9D,SACO,OAAO,iBACP;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,GACnB,OAAO,CAAC,6BAA6B,CAAC,CAiBlD;AAeM,yCAVI,YAAY,+CAEpB;IAAsC,QAAQ,EAAtC,eAAe,QAAQ,CAAC;IAC6C,mBAAmB,EAAxF,OAAO,CAAC,eAAe,4BAA4B,CAAC,QAAQ,CAAC,CAAC,CAAC;IACjC,QAAQ,EAAtC,eAAe,QAAQ,CAAC;CAChC,WAAQ,eAAe,0BAA0B,CAAC,QAC1C,OAAO,aACP,sBAAsB,GACpB,OAAO,CAAC,IAAI,CAAC,CAoCzB;AAcM,4CATI,YAAY,OACZ,MAAM,WACN,eAAe,0BAA0B,CAAC,gCAC1C;IACN,WAAW,EAAE;QAAE,MAAM,EAAE,SAAS,CAAC;QAAC,SAAS,EAAE,sBAAsB,CAAA;KAAE,EAAE,CAAC;IACxE,WAAW,EAAE,YAAY,CAAC;CAC3B,GACS,OAAO,CAAC,IAAI,CAAC,CAYzB;kCAlH6J,aAAa;iDAG7H,sCAAsC;sCAF1B,mCAAmC;mDAInC,uBAAuB;8BAL6E,aAAa;oCAD1I,oBAAoB;kDAGN,wCAAwC;8BAG7B,uBAAuB;gDADpC,yCAAyC;4CAJwE,aAAa;+BAAb,aAAa;kCAAb,aAAa"}

package/src/examples/staking-combinations.flows.js

@@ -1,6 +1,6 @@
 /**
  * @import {GuestInterface} from '@agoric/async-flow';
- * @import {Orchestrator, OrchestrationFlow, AmountArg, CosmosValidatorAddress, CosmosChainAddress, LocalAccountMethods, OrchestrationAccountCommon, ChainHub} from '../types.js'
+ * @import {Orchestrator, OrchestrationFlow, AmountArg, CosmosValidatorAddress, ChainAddress, LocalAccountMethods, OrchestrationAccountCommon, ChainHub} from '../types.js'
  * @import {ContinuingOfferResult, InvitationMakers} from '@agoric/smart-wallet/src/types.js';
  * @import {LocalOrchestrationAccountKit} from '../exos/local-orchestration-account.js';
  * @import {MakeCombineInvitationMakers} from '../exos/combine-invitation-makers.js';
@@ -11,7 +11,7 @@
 import { mustMatch } from '@endo/patterns';
 import { Fail, makeError, q } from '@endo/errors';
 import { makeTracer } from '@agoric/internal';
-import { CosmosChainAddressShape } from '../typeGuards.js';
+import { ChainAddressShape } from '../typeGuards.js';
 
 const trace = makeTracer('StakingCombinationsFlows');
 
@@ -65,7 +65,7 @@ export const depositAndDelegate = async (
 ) => {
   await null;
   trace('depositAndDelegate', account, seat, validator);
-  mustMatch(validator, CosmosChainAddressShape);
+  mustMatch(validator, ChainAddressShape);
 
   const { give } = seat.getProposal();
   /**
@@ -100,7 +100,7 @@ harden(depositAndDelegate);
  * @param {GuestInterface<CosmosOrchestrationAccount>} account
  * @param {{
  *   delegations: { amount: AmountArg; validator: CosmosValidatorAddress }[];
- *   destination: CosmosChainAddress;
+ *   destination: ChainAddress;
  * }} offerArgs
  * @returns {Promise<void>}
  */

package/src/examples/swap.contract.d.ts

@@ -14,20 +14,30 @@ export function makeNatAmountShape(brand: Brand, min?: NatValue): {
     brand: globalThis.Brand;
     value: import("@endo/patterns").Matcher;
 };
-export const start: (zcf: globalThis.ZCF<Record<string, unknown>>, privateArgs: {
+export const start: (zcf: ZCF<Record<string, unknown>>, privateArgs: {
     agoricNames: Remote<NameHub>;
     localchain: Remote<LocalChain>;
     orchestrationService: Remote<CosmosInterchainService>;
     storageNode: Remote<StorageNode>;
     timerService: Remote<TimerService>;
     marshaller: Marshaller;
-    chainInfo: Record<string, CosmosChainInfo>;
+    chainInfo: Record<string, Readonly<{
+        bech32Prefix?: string;
+        chainId: string;
+        connections?: Record<string, import("@agoric/orchestration").IBCConnectionInfo>;
+        icqEnabled?: boolean;
+        pfmEnabled?: boolean;
+        stakingTokens?: Readonly<Array<{
+            denom: string;
+        }>>;
+        icaEnabled?: boolean;
+    }>>;
     assetInfo: [Denom, DenomDetail & {
         brandKey?: string;
     }][];
 }, baggage: import("@agoric/vat-data").Baggage) => Promise<{
     publicFacet: import("@endo/exo").Guarded<{
-        makeSwapAndStakeInvitation(): Promise<globalThis.Invitation<import("@agoric/vow").Vow<void>, {
+        makeSwapAndStakeInvitation(): Promise<Invitation<import("@agoric/vow").Vow<void>, {
             staked: Amount<"nat">;
             validator: import("@agoric/orchestration").CosmosValidatorAddress;
         }>>;
@@ -38,7 +48,6 @@ import type { Remote } from '@agoric/internal';
 import type { LocalChain } from '@agoric/vats/src/localchain.js';
 import type { CosmosInterchainService } from '../exos/exo-interfaces.js';
 import type { TimerService } from '@agoric/time';
-import type { CosmosChainInfo } from '@agoric/orchestration';
 import type { Denom } from '@agoric/orchestration';
 import type { DenomDetail } from '@agoric/orchestration';
 //# sourceMappingURL=swap.contract.d.ts.map

package/src/examples/swap.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swap.contract.d.ts","sourceRoot":"","sources":["swap.contract.js"],"names":[],"mappings":"AAOA;;;;;;;;;GASG;AAEH,yCAAyC;AACzC,mBADW,YAAY,CAAC,OAAO,KAAK,CAAC,CAanC;AASK,0CAHI,KAAK,QACL,QAAQ;;;EAGmC;AAkDtD;iBA1CkB,OAAO,OAAO,CAAC;gBAChB,OAAO,UAAU,CAAC;0BACR,OAAO,uBAAuB,CAAC;iBACxC,OAAO,WAAW,CAAC;kBAClB,OAAO,YAAY,CAAC;gBACtB,UAAU;eACX,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC;eAC/B,CAAC,KAAK,EAAE,WAAW,GAAG;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE;;;;;;;;GAmCiB;6BA/ErD,cAAc;4BAFf,kBAAkB;gCADd,gCAAgC;6CAEnB,2BAA2B;kCAHtC,cAAc;qCAOS,uBAAuB;2BAAvB,uBAAuB;iCAAvB,uBAAuB"}
+{"version":3,"file":"swap.contract.d.ts","sourceRoot":"","sources":["swap.contract.js"],"names":[],"mappings":"AAOA;;;;;;;;;GASG;AAEH,yCAAyC;AACzC,mBADW,YAAY,CAAC,OAAO,KAAK,CAAC,CAanC;AASK,0CAHI,KAAK,QACL,QAAQ;;;EAGmC;AAkDtD;iBA1CkB,OAAO,OAAO,CAAC;gBAChB,OAAO,UAAU,CAAC;0BACR,OAAO,uBAAuB,CAAC;iBACxC,OAAO,WAAW,CAAC;kBAClB,OAAO,YAAY,CAAC;gBACtB,UAAU;;;;;;;;;;;;eAEX,CAAC,KAAK,EAAE,WAAW,GAAG;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE;;;;;;;;GAmCiB;6BA/ErD,cAAc;4BAFf,kBAAkB;gCADd,gCAAgC;6CAEnB,2BAA2B;kCAHtC,cAAc;2BAOS,uBAAuB;iCAAvB,uBAAuB"}

package/src/examples/swap.contract.js

@@ -3,7 +3,7 @@ import { TimerServiceShape } from '@agoric/time';
 import { M } from '@endo/patterns';
 import { withOrchestration } from '../utils/start-helper.js';
 import * as flows from './swap.flows.js';
-import { ChainInfoShape, DenomDetailShape } from '../typeGuards.js';
+import { CosmosChainInfoShape, DenomDetailShape } from '../typeGuards.js';
 
 /**
  * @import {TimerService} from '@agoric/time';
@@ -25,7 +25,7 @@ export const meta = {
     storageNode: StorageNodeShape,
     marshaller: M.remotable('marshaller'),
     timerService: M.or(TimerServiceShape, null),
-    chainInfo: M.recordOf(M.string(), ChainInfoShape),
+    chainInfo: M.recordOf(M.string(), CosmosChainInfoShape),
     assetInfo: M.arrayOf([M.string(), DenomDetailShape]),
   },
   upgradability: 'canUpgrade',