@agoric/orchestration 0.2.0 → 0.2.1-upgrade-23-dev-bd79330.0.bd79330

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

@@ -1,52 +1,246 @@
 /**
  * @import {Baggage} from '@agoric/vat-data';
- * @import {Remote} from '@agoric/internal';
+ * @import {ERemote, Remote} from '@agoric/internal';
  * @import {CosmosChainInfo, CosmosInterchainService, Denom, DenomDetail} from '@agoric/orchestration';
  * @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';
+ * @import {StorageNode} from '@agoric/internal/src/lib-chainStorage.js';
+ * @import {Marshaller} from '@agoric/internal/src/lib-chainStorage.js';
  */
 /** @type {ContractMeta<typeof start>} */
 export const meta: ContractMeta<typeof start>;
 export const privateArgsShape: {
-    agoricNames: Pattern;
-    cosmosInterchainService: Pattern;
-    storageNode: Pattern;
-    marshaller: Pattern;
-    timer: Pattern;
+    agoricNames: import("@endo/patterns").Pattern;
+    cosmosInterchainService: import("@endo/patterns").Pattern;
+    storageNode: import("@endo/patterns").Pattern;
+    marshaller: import("@endo/patterns").Pattern;
+    timer: import("@endo/patterns").Pattern;
 } | undefined;
 export function start(zcf: ZCF<StakeIcaTerms>, privateArgs: {
     agoricNames: Remote<NameHub>;
     cosmosInterchainService: CosmosInterchainService;
-    storageNode: StorageNode;
-    marshaller: Marshaller;
+    storageNode: Remote<StorageNode>;
+    marshaller: Remote<Marshaller>;
     timer: TimerService;
 }, baggage: Baggage): Promise<{
     publicFacet: import("@endo/exo").Guarded<{
         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("@agoric/orchestration").CosmosChainAddress>;
-            delegate(validator: import("@agoric/orchestration").CosmosValidatorAddress, amount: import("@agoric/orchestration").AmountArg): import("@agoric/vow").Vow<void>;
-            redelegate(srcValidator: import("@agoric/orchestration").CosmosValidatorAddress, dstValidator: import("@agoric/orchestration").CosmosValidatorAddress, amount: import("@agoric/orchestration").AmountArg): import("@agoric/vow").Vow<void>;
-            withdrawReward(validator: import("@agoric/orchestration").CosmosValidatorAddress): import("@agoric/vow").Vow<import("@agoric/orchestration").DenomAmount[]>;
-            getBalance(denom: import("@agoric/orchestration").DenomArg): import("@agoric/vow").Vow<import("@agoric/orchestration").DenomAmount>;
-            getBalances(): import("@agoric/vow").Vow<import("@agoric/orchestration").DenomAmount[]>;
-            send(toAccount: import("@agoric/orchestration").AccountIdArg, amount: import("@agoric/orchestration").AmountArg): import("@agoric/vow").Vow<void>;
-            sendAll(toAccount: import("@agoric/orchestration").CosmosChainAddress, amounts: import("@agoric/orchestration").AmountArg[]): import("@agoric/vow").Vow<void>;
-            transfer(destination: import("@agoric/orchestration").AccountIdArg, amount: import("@agoric/orchestration").AmountArg, opts?: import("@agoric/orchestration").IBCMsgTransferOptions | undefined): import("@agoric/vow").Vow<void>;
-            transferSteps(amount: import("@agoric/orchestration").AmountArg, msg: import("@agoric/orchestration").TransferMsg): import("@agoric/vow").Vow<void>;
-            withdrawRewards(): import("@agoric/vow").Vow<import("@agoric/orchestration").DenomAmount[]>;
+            makeProgressTracker(): import("@agoric/orchestration").ProgressTracker;
+            asContinuingOffer(): import("@agoric/vow").Vow<{
+                invitationMakers: {
+                    [x: string]: (...args: any[]) => import("@agoric/vow").Vow<import("@endo/pass-style").RemotableObject & {
+                        getAllegedBrand: () => import("@agoric/ertp").Brand<"set">;
+                    } & {
+                        readonly "Symbol(tag)": {
+                            "Set-like value type": import("@agoric/zoe").InvitationDetails;
+                        };
+                    }>;
+                };
+                publicSubscribers: {
+                    [x: string]: {
+                        description?: string | undefined;
+                        subscriber: {
+                            getUpdateSince: (updateCount?: number | bigint | undefined) => import("@agoric/vow").Vow<{
+                                value: any;
+                                updateCount?: bigint | undefined | undefined;
+                            }>;
+                            subscribeAfter: (publishCount?: bigint | undefined) => import("@agoric/vow").Vow<{
+                                head: {
+                                    done: true;
+                                    value: any;
+                                } | {
+                                    done?: false | undefined;
+                                    value: any;
+                                };
+                                publishCount: bigint;
+                                tail: {
+                                    "Symbol(passStyle)": "tagged";
+                                    [Symbol.toStringTag]: "Vow";
+                                    payload: import("@agoric/vow").VowPayload</*elided*/ any>;
+                                };
+                            }>;
+                        } | {};
+                        storagePath: string;
+                    };
+                };
+            }>;
+            getPublicTopics(): import("@agoric/vow").Vow<{
+                [x: string]: {
+                    description?: string | undefined;
+                    subscriber: {
+                        getUpdateSince: (updateCount?: number | bigint | undefined) => import("@agoric/vow").Vow<{
+                            value: {};
+                            updateCount?: bigint | undefined | undefined;
+                        }>;
+                        subscribeAfter: (publishCount?: bigint | undefined) => import("@agoric/vow").Vow<{
+                            head: {
+                                done: true;
+                                value: any;
+                            } | {
+                                done?: false | undefined;
+                                value: {};
+                            };
+                            publishCount: bigint;
+                            tail: {
+                                "Symbol(passStyle)": "tagged";
+                                [Symbol.toStringTag]: "Vow";
+                                payload: import("@agoric/vow").VowPayload</*elided*/ any>;
+                            };
+                        }>;
+                    } | {};
+                    storagePath: string;
+                };
+            }>;
+            getAddress(): {
+                chainId: string;
+                value: import("@agoric/orchestration").Bech32Address;
+                encoding: "bech32";
+            };
+            delegate(validator: import("@agoric/orchestration").CosmosValidatorAddress, amount: import("@agoric/orchestration").AmountArg, opts?: import("@agoric/orchestration").CosmosActionOptions | undefined): import("@agoric/vow").Vow<{}>;
+            redelegate(srcValidator: import("@agoric/orchestration").CosmosValidatorAddress, dstValidator: import("@agoric/orchestration").CosmosValidatorAddress, amount: import("@agoric/orchestration").AmountArg, opts?: import("@agoric/orchestration").CosmosActionOptions | undefined): import("@agoric/vow").Vow<{}>;
+            withdrawReward(validator: import("@agoric/orchestration").CosmosValidatorAddress, opts?: import("@agoric/orchestration").CosmosActionOptions | undefined): import("@agoric/vow").Vow<{
+                denom: Denom;
+                value: bigint;
+            }[]>;
+            getBalance(denom: import("@agoric/orchestration").DenomArg, opts?: import("@agoric/orchestration").QuerierOptions | undefined): import("@agoric/vow").Vow<{
+                denom: Denom;
+                value: bigint;
+            }>;
+            getBalances(opts?: import("@agoric/orchestration").QuerierOptions | undefined): import("@agoric/vow").Vow<{
+                denom: Denom;
+                value: bigint;
+            }[]>;
+            send(toAccount: import("@agoric/orchestration").AccountIdArg, amount: import("@agoric/orchestration").AmountArg, opts?: import("@agoric/orchestration").ActionOptions | undefined): import("@agoric/vow").Vow<{}>;
+            sendAll(toAccount: import("@agoric/orchestration").CosmosChainAddress, amounts: import("@agoric/orchestration").AmountArg[], opts?: import("@agoric/orchestration").ActionOptions | undefined): import("@agoric/vow").Vow<{}>;
+            transfer(destination: import("@agoric/orchestration").AccountIdArg, amount: import("@agoric/orchestration").AmountArg, opts?: import("@agoric/orchestration").IBCMsgTransferOptions | undefined): import("@agoric/vow").Vow<{}>;
+            transferSteps(amount: import("@agoric/orchestration").AmountArg, msg: import("@agoric/orchestration").TransferMsg): import("@agoric/vow").Vow<{}>;
+            withdrawRewards(opts?: import("@agoric/orchestration").CosmosActionOptions | undefined): import("@agoric/vow").Vow<{
+                denom: Denom;
+                value: bigint;
+            }[]>;
             undelegate(delegations: {
                 amount: import("@agoric/orchestration").AmountArg;
                 delegator?: import("@agoric/orchestration").CosmosChainAddress;
                 validator: import("@agoric/orchestration").CosmosValidatorAddress;
-            }[]): import("@agoric/vow").Vow<void>;
+            }[], opts?: import("@agoric/orchestration").CosmosActionOptions | undefined): import("@agoric/vow").Vow<{}>;
             deactivate(): import("@agoric/vow").Vow<void>;
             reactivate(): import("@agoric/vow").Vow<void>;
-            getDelegation(validator: import("@agoric/orchestration").CosmosValidatorAddress): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("@agoric/orchestration").CosmosDelegationResponse>>;
-            getDelegations(): import("@agoric/vow").Vow<{
+            getDelegation(validator: import("@agoric/orchestration").CosmosValidatorAddress, opts?: import("@agoric/orchestration").CosmosQuerierOptions | undefined): import("@agoric/vow").Vow<{
+                delegator: {
+                    chainId: string;
+                    value: import("@agoric/orchestration").Bech32Address;
+                    encoding: "bech32";
+                };
+                validator: {
+                    chainId: string;
+                    value: {
+                        readonly [x: number]: string;
+                        toString: () => string;
+                        charAt: (pos: number) => string;
+                        charCodeAt: (index: number) => number;
+                        concat: (...strings: string[]) => string;
+                        indexOf: (searchString: string, position?: number) => number;
+                        lastIndexOf: (searchString: string, position?: number) => number;
+                        localeCompare: {
+                            (that: string): number;
+                            (that: string, locales?: string | string[], options?: Intl.CollatorOptions): number;
+                            (that: string, locales?: Intl.LocalesArgument, options?: Intl.CollatorOptions): number;
+                        };
+                        match: {
+                            (regexp: string | RegExp): RegExpMatchArray | null;
+                            (matcher: {
+                                [Symbol.match](string: string): RegExpMatchArray | null;
+                            }): RegExpMatchArray | null;
+                        };
+                        replace: {
+                            (searchValue: string | RegExp, replaceValue: string): string;
+                            (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
+                            (searchValue: {
+                                [Symbol.replace](string: string, replaceValue: string): string;
+                            }, replaceValue: string): string;
+                            (searchValue: {
+                                [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string;
+                            }, replacer: (substring: string, ...args: any[]) => string): string;
+                        };
+                        search: {
+                            (regexp: string | RegExp): number;
+                            (searcher: {
+                                [Symbol.search](string: string): number;
+                            }): number;
+                        };
+                        slice: (start?: number, end?: number) => string;
+                        split: {
+                            (separator: string | RegExp, limit?: number): string[];
+                            (splitter: {
+                                [Symbol.split](string: string, limit?: number): string[];
+                            }, limit?: number): string[];
+                        };
+                        substring: (start: number, end?: number) => string;
+                        toLowerCase: () => string;
+                        toLocaleLowerCase: {
+                            (locales?: string | string[]): string;
+                            (locales?: Intl.LocalesArgument): string;
+                        };
+                        toUpperCase: () => string;
+                        toLocaleUpperCase: {
+                            (locales?: string | string[]): string;
+                            (locales?: Intl.LocalesArgument): string;
+                        };
+                        trim: () => string;
+                        readonly length: number;
+                        substr: (from: number, length?: number) => string;
+                        valueOf: () => string;
+                        codePointAt: (pos: number) => number | undefined;
+                        includes: (searchString: string, position?: number) => boolean;
+                        endsWith: (searchString: string, endPosition?: number) => boolean;
+                        normalize: {
+                            (form: "NFC" | "NFD" | "NFKC" | "NFKD"): string;
+                            (form?: string): string;
+                        };
+                        repeat: (count: number) => string;
+                        startsWith: (searchString: string, position?: number) => boolean;
+                        anchor: (name: string) => string;
+                        big: () => string;
+                        blink: () => string;
+                        bold: () => string;
+                        fixed: () => string;
+                        fontcolor: (color: string) => string;
+                        fontsize: {
+                            (size: number): string;
+                            (size: string): string;
+                        };
+                        italics: () => string;
+                        link: (url: string) => string;
+                        small: () => string;
+                        strike: () => string;
+                        sub: () => string;
+                        sup: () => string;
+                        padStart: (maxLength: number, fillString?: string) => string;
+                        padEnd: (maxLength: number, fillString?: string) => string;
+                        trimEnd: () => string;
+                        trimStart: () => string;
+                        trimLeft: () => string;
+                        trimRight: () => string;
+                        matchAll: (regexp: RegExp) => RegExpStringIterator<RegExpExecArray>;
+                        replaceAll: {
+                            (searchValue: string | RegExp, replaceValue: string): string;
+                            (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
+                        };
+                        at: (index: number) => string | undefined;
+                        isWellFormed: () => boolean;
+                        toWellFormed: () => string;
+                        [Symbol.iterator]: () => StringIterator<string>;
+                    };
+                    encoding: "bech32";
+                };
+                amount: {
+                    denom: Denom;
+                    value: bigint;
+                };
+            }>;
+            getDelegations(opts?: import("@agoric/orchestration").CosmosQuerierOptions | undefined): import("@agoric/vow").Vow<{
                 delegator: {
                     chainId: string;
                     value: import("@agoric/orchestration").Bech32Address;
@@ -59,65 +253,98 @@ export function start(zcf: ZCF<StakeIcaTerms>, privateArgs: {
                         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;
+                        concat: (...strings: string[]) => string;
+                        indexOf: (searchString: string, position?: number) => number;
+                        lastIndexOf: (searchString: string, position?: number) => number;
+                        localeCompare: {
+                            (that: string): number;
+                            (that: string, locales?: string | string[], options?: Intl.CollatorOptions): number;
+                            (that: string, locales?: Intl.LocalesArgument, options?: Intl.CollatorOptions): number;
+                        };
+                        match: {
+                            (regexp: string | RegExp): RegExpMatchArray | null;
+                            (matcher: {
+                                [Symbol.match](string: string): RegExpMatchArray | null;
+                            }): RegExpMatchArray | null;
+                        };
+                        replace: {
+                            (searchValue: string | RegExp, replaceValue: string): string;
+                            (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
+                            (searchValue: {
+                                [Symbol.replace](string: string, replaceValue: string): string;
+                            }, replaceValue: string): string;
+                            (searchValue: {
+                                [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string;
+                            }, replacer: (substring: string, ...args: any[]) => string): string;
+                        };
+                        search: {
+                            (regexp: string | RegExp): number;
+                            (searcher: {
+                                [Symbol.search](string: string): number;
+                            }): number;
+                        };
+                        slice: (start?: number, end?: number) => string;
+                        split: {
+                            (separator: string | RegExp, limit?: number): string[];
+                            (splitter: {
+                                [Symbol.split](string: string, limit?: number): string[];
+                            }, limit?: number): string[];
+                        };
+                        substring: (start: number, end?: number) => string;
                         toLowerCase: () => string;
-                        toLocaleLowerCase: (locales?: Intl.LocalesArgument) => string;
+                        toLocaleLowerCase: {
+                            (locales?: string | string[]): string;
+                            (locales?: Intl.LocalesArgument): string;
+                        };
                         toUpperCase: () => string;
-                        toLocaleUpperCase: (locales?: Intl.LocalesArgument) => string;
+                        toLocaleUpperCase: {
+                            (locales?: string | string[]): string;
+                            (locales?: Intl.LocalesArgument): string;
+                        };
                         trim: () => string;
                         readonly length: number;
-                        substr: (from: number, length?: number | undefined) => string;
+                        substr: (from: number, length?: number) => 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;
+                        codePointAt: (pos: number) => number | undefined;
+                        includes: (searchString: string, position?: number) => boolean;
+                        endsWith: (searchString: string, endPosition?: number) => boolean;
+                        normalize: {
+                            (form: "NFC" | "NFD" | "NFKC" | "NFKD"): string;
+                            (form?: string): string;
+                        };
                         repeat: (count: number) => string;
-                        startsWith: ((searchString: string, position?: number | undefined) => false) | ((searchString: string, position?: number | undefined) => true);
+                        startsWith: (searchString: string, position?: number) => boolean;
                         anchor: (name: string) => string;
                         big: () => string;
                         blink: () => string;
                         bold: () => string;
                         fixed: () => string;
                         fontcolor: (color: string) => string;
-                        fontsize: (size: string) => string;
+                        fontsize: {
+                            (size: number): string;
+                            (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;
+                        padStart: (maxLength: number, fillString?: string) => string;
+                        padEnd: (maxLength: number, fillString?: string) => 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);
+                        matchAll: (regexp: RegExp) => RegExpStringIterator<RegExpExecArray>;
+                        replaceAll: {
+                            (searchValue: string | RegExp, replaceValue: string): string;
+                            (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
+                        };
+                        at: (index: number) => string | undefined;
+                        isWellFormed: () => boolean;
                         toWellFormed: () => string;
-                        [Symbol.iterator]: () => import("@agoric/async-flow").HostInterface<StringIterator<string>>;
+                        [Symbol.iterator]: () => StringIterator<string>;
                     };
                     encoding: "bech32";
                 };
@@ -126,8 +353,22 @@ export function start(zcf: ZCF<StakeIcaTerms>, privateArgs: {
                     value: bigint;
                 };
             }[]>;
-            getUnbondingDelegation(validator: import("@agoric/orchestration").CosmosValidatorAddress): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").UnbondingDelegation>>;
-            getUnbondingDelegations(): import("@agoric/vow").Vow<{
+            getUnbondingDelegation(validator: import("@agoric/orchestration").CosmosValidatorAddress, opts?: import("@agoric/orchestration").CosmosQuerierOptions | undefined): import("@agoric/vow").Vow<{
+                delegatorAddress: string;
+                validatorAddress: string;
+                entries: {
+                    creationHeight: bigint;
+                    completionTime: {
+                        seconds: bigint;
+                        nanos: number;
+                    };
+                    initialBalance: string;
+                    balance: string;
+                    unbondingId: bigint;
+                    unbondingOnHoldRefCount: bigint;
+                }[];
+            }>;
+            getUnbondingDelegations(opts?: import("@agoric/orchestration").CosmosQuerierOptions | undefined): import("@agoric/vow").Vow<{
                 delegatorAddress: string;
                 validatorAddress: string;
                 entries: {
@@ -142,7 +383,7 @@ export function start(zcf: ZCF<StakeIcaTerms>, privateArgs: {
                     unbondingOnHoldRefCount: bigint;
                 }[];
             }[]>;
-            getRedelegations(): import("@agoric/vow").Vow<{
+            getRedelegations(opts?: import("@agoric/orchestration").CosmosQuerierOptions | undefined): import("@agoric/vow").Vow<{
                 redelegation: {
                     delegatorAddress: string;
                     validatorSrcAddress: string;
@@ -174,16 +415,136 @@ export function start(zcf: ZCF<StakeIcaTerms>, privateArgs: {
                     balance: string;
                 }[];
             }[]>;
-            getReward(validator: import("@agoric/orchestration").CosmosValidatorAddress): import("@agoric/vow").Vow<import("@agoric/orchestration").DenomAmount[]>;
-            getRewards(): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("@agoric/orchestration").CosmosRewardsResponse>>;
-            executeEncodedTx(msgs: {
+            getReward(validator: import("@agoric/orchestration").CosmosValidatorAddress, opts?: import("@agoric/orchestration").CosmosQuerierOptions | undefined): import("@agoric/vow").Vow<{
+                denom: Denom;
+                value: bigint;
+            }[]>;
+            getRewards(opts?: import("@agoric/orchestration").CosmosQuerierOptions | undefined): import("@agoric/vow").Vow<{
+                rewards: {
+                    validator: {
+                        chainId: string;
+                        value: {
+                            readonly [x: number]: string;
+                            toString: () => string;
+                            charAt: (pos: number) => string;
+                            charCodeAt: (index: number) => number;
+                            concat: (...strings: string[]) => string;
+                            indexOf: (searchString: string, position?: number) => number;
+                            lastIndexOf: (searchString: string, position?: number) => number;
+                            localeCompare: {
+                                (that: string): number;
+                                (that: string, locales?: string | string[], options?: Intl.CollatorOptions): number;
+                                (that: string, locales?: Intl.LocalesArgument, options?: Intl.CollatorOptions): number;
+                            };
+                            match: {
+                                (regexp: string | RegExp): RegExpMatchArray | null;
+                                (matcher: {
+                                    [Symbol.match](string: string): RegExpMatchArray | null;
+                                }): RegExpMatchArray | null;
+                            };
+                            replace: {
+                                (searchValue: string | RegExp, replaceValue: string): string;
+                                (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
+                                (searchValue: {
+                                    [Symbol.replace](string: string, replaceValue: string): string;
+                                }, replaceValue: string): string;
+                                (searchValue: {
+                                    [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string;
+                                }, replacer: (substring: string, ...args: any[]) => string): string;
+                            };
+                            search: {
+                                (regexp: string | RegExp): number;
+                                (searcher: {
+                                    [Symbol.search](string: string): number;
+                                }): number;
+                            };
+                            slice: (start?: number, end?: number) => string;
+                            split: {
+                                (separator: string | RegExp, limit?: number): string[];
+                                (splitter: {
+                                    [Symbol.split](string: string, limit?: number): string[];
+                                }, limit?: number): string[];
+                            };
+                            substring: (start: number, end?: number) => string;
+                            toLowerCase: () => string;
+                            toLocaleLowerCase: {
+                                (locales?: string | string[]): string;
+                                (locales?: Intl.LocalesArgument): string;
+                            };
+                            toUpperCase: () => string;
+                            toLocaleUpperCase: {
+                                (locales?: string | string[]): string;
+                                (locales?: Intl.LocalesArgument): string;
+                            };
+                            trim: () => string;
+                            readonly length: number;
+                            substr: (from: number, length?: number) => string;
+                            valueOf: () => string;
+                            codePointAt: (pos: number) => number | undefined;
+                            includes: (searchString: string, position?: number) => boolean;
+                            endsWith: (searchString: string, endPosition?: number) => boolean;
+                            normalize: {
+                                (form: "NFC" | "NFD" | "NFKC" | "NFKD"): string;
+                                (form?: string): string;
+                            };
+                            repeat: (count: number) => string;
+                            startsWith: (searchString: string, position?: number) => boolean;
+                            anchor: (name: string) => string;
+                            big: () => string;
+                            blink: () => string;
+                            bold: () => string;
+                            fixed: () => string;
+                            fontcolor: (color: string) => string;
+                            fontsize: {
+                                (size: number): string;
+                                (size: string): string;
+                            };
+                            italics: () => string;
+                            link: (url: string) => string;
+                            small: () => string;
+                            strike: () => string;
+                            sub: () => string;
+                            sup: () => string;
+                            padStart: (maxLength: number, fillString?: string) => string;
+                            padEnd: (maxLength: number, fillString?: string) => string;
+                            trimEnd: () => string;
+                            trimStart: () => string;
+                            trimLeft: () => string;
+                            trimRight: () => string;
+                            matchAll: (regexp: RegExp) => RegExpStringIterator<RegExpExecArray>;
+                            replaceAll: {
+                                (searchValue: string | RegExp, replaceValue: string): string;
+                                (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
+                            };
+                            at: (index: number) => string | undefined;
+                            isWellFormed: () => boolean;
+                            toWellFormed: () => string;
+                            [Symbol.iterator]: () => StringIterator<string>;
+                        };
+                        encoding: "bech32";
+                    };
+                    reward: {
+                        denom: Denom;
+                        value: bigint;
+                    }[];
+                }[];
+                total: {
+                    denom: Denom;
+                    value: bigint;
+                }[];
+            }>;
+            executeEncodedTx(msgs: readonly {
+                $typeUrl?: "/google.protobuf.Any" | string | undefined;
+                typeUrl: string;
+                value: string;
+            }[], opts?: (Partial<Omit<import("@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js").TxBody, "messages">> & Omit<import("@agoric/orchestration").CosmosActionOptions, "txOpts">) | undefined): import("@agoric/vow").Vow<string>;
+            executeTxProto3Undecoded(msgs: readonly {
                 $typeUrl?: "/google.protobuf.Any" | string | undefined;
                 typeUrl: string;
                 value: string;
-            }[], opts?: (Partial<Omit<import("@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js").TxBody, "messages">> & {
-                sendOpts?: import("@agoric/network").SendOptions;
-            }) | undefined): import("@agoric/vow").Vow<string>;
-            depositForBurn(mintRecipient: `${string}:${string}:${string}`, amount: import("@agoric/orchestration").AmountArg, caller?: `${string}:${string}:${string}` | undefined): import("@agoric/vow").Vow<void>;
+            }[], opts?: import("@agoric/orchestration").CosmosActionOptions | undefined): import("@agoric/vow").Vow<string>;
+            executeTxProto3<TUS extends readonly (keyof import("@agoric/cosmic-proto").TypeFromUrl | unknown)[]>(msgs: { readonly [K in keyof TUS]: import("@agoric/cosmic-proto").AnyJson<TUS[K]>; }, opts?: import("@agoric/orchestration").CosmosActionOptions): import("@agoric/vow").Vow<{ [K in keyof TUS]: import("@agoric/cosmic-proto").MessageBody<import("@agoric/cosmic-proto").ResponseTypeUrl<TUS[K]>>; }>;
+            depositForBurn(mintRecipient: `${string}:${string}:${string}`, amount: import("@agoric/orchestration").AmountArg, caller?: `${string}:${string}:${string}` | undefined, opts?: import("@agoric/orchestration").CosmosActionOptions | undefined): import("@agoric/vow").Vow<{}>;
         }>>;
         makeAccountInvitationMaker(): Promise<Invitation<ResolvedContinuingOfferResult, undefined>>;
     }>;
@@ -200,10 +561,12 @@ import type { ZCF } from '@agoric/zoe';
 import type { NameHub } from '@agoric/vats';
 import type { Remote } from '@agoric/internal';
 import type { CosmosInterchainService } from '@agoric/orchestration';
+import type { StorageNode } from '@agoric/internal/src/lib-chainStorage.js';
+import type { Marshaller } from '@agoric/internal/src/lib-chainStorage.js';
 import type { TimerService } from '@agoric/time';
 import type { Baggage } from '@agoric/vat-data';
-import type { ResolvedContinuingOfferResult } from '../utils/zoe-tools.js';
 import type { Denom } from '@agoric/orchestration';
+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;kCAxJ+B,aAAa;yBAAb,aAAa;6BAC3B,cAAc;4BAHhC,kBAAkB;6CACoC,uBAAuB;kCAGvE,cAAc;6BALnB,kBAAkB;mDAMI,uBAAuB;2BAJQ,uBAAuB;gCAC7C,aAAa;qCAC3B,cAAc"}
+{"version":3,"file":"stake-ica.contract.d.ts","sourceRoot":"","sources":["stake-ica.contract.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;GAUG;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,OAAO,WAAW,CAAC,CAAC;IACjC,UAAU,EAAE,OAAO,UAAU,CAAC,CAAC;IAC/B,KAAK,EAAE,YAAY,CAAC;CACrB,WACO,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yHA+Hi6gD,QAAsB;;;;;GAJx8gD;4BA5IY;IACR,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,eAAe,CAAC;IAClC,sBAAsB,EAAE,eAAe,CAAC;IACxC,UAAU,EAAE,OAAO,CAAC;CACrB;yBA0IU,OAAO,KAAK;kCA5K+B,aAAa;yBAAb,aAAa;6BAC3B,cAAc;4BAHvB,kBAAkB;6CAC2B,uBAAuB;iCAKxE,0CAA0C;gCAC3C,0CAA0C;kCAHxC,cAAc;6BALnB,kBAAkB;2BAEmC,uBAAuB;mDAItD,uBAAuB;gCAHd,aAAa;qCAC3B,cAAc"}