@agoric/orchestration 0.3.0-u23.0 → 0.3.0-u23.1

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

@@ -0,0 +1,573 @@
+/**
+ * @import {Baggage} from '@agoric/vat-data';
+ * @import {ERemote, Remote} from '@agoric/internal';
+ * @import {CosmosChainInfo, CosmosInterchainService, Denom, DenomDetail} from '@agoric/orchestration';
+ * @import {ContractMeta, Invitation, ZCF, ZCFSeat} from '@agoric/zoe';
+ * @import {IBCConnectionID} from '@agoric/network/ibc';
+ * @import {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: 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: Remote<StorageNode>;
+    marshaller: Remote<Marshaller>;
+    timer: TimerService;
+}, baggage: Baggage): Promise<{
+    publicFacet: import("@endo/exo").Guarded<{
+        makeAccount(): Promise<import("@endo/exo").Guarded<{
+            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;
+            }[], 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, 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;
+                    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;
+                };
+            }[]>;
+            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: {
+                    creationHeight: bigint;
+                    completionTime: {
+                        seconds: bigint;
+                        nanos: number;
+                    };
+                    initialBalance: string;
+                    balance: string;
+                    unbondingId: bigint;
+                    unbondingOnHoldRefCount: bigint;
+                }[];
+            }[]>;
+            getRedelegations(opts?: import("@agoric/orchestration").CosmosQuerierOptions | undefined): import("@agoric/vow").Vow<{
+                redelegation: {
+                    delegatorAddress: string;
+                    validatorSrcAddress: string;
+                    validatorDstAddress: string;
+                    entries: {
+                        creationHeight: bigint;
+                        completionTime: {
+                            seconds: bigint;
+                            nanos: number;
+                        };
+                        initialBalance: string;
+                        sharesDst: string;
+                        unbondingId: bigint;
+                        unbondingOnHoldRefCount: bigint;
+                    }[];
+                };
+                entries: {
+                    redelegationEntry: {
+                        creationHeight: bigint;
+                        completionTime: {
+                            seconds: bigint;
+                            nanos: number;
+                        };
+                        initialBalance: string;
+                        sharesDst: string;
+                        unbondingId: bigint;
+                        unbondingOnHoldRefCount: bigint;
+                    };
+                    balance: string;
+                }[];
+            }[]>;
+            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?: 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>>;
+    }>;
+}>;
+export type StakeIcaTerms = {
+    chainId: string;
+    hostConnectionId: IBCConnectionID;
+    controllerConnectionId: IBCConnectionID;
+    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 '@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 { Denom } from '@agoric/orchestration';
+import type { ResolvedContinuingOfferResult } from '../utils/zoe-tools.js';
+import type { Invitation } from '@agoric/zoe';
+import type { IBCConnectionID } from '@agoric/network/ibc';
+//# sourceMappingURL=stake-ica.contract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stake-ica.contract.d.ts","sourceRoot":"","sources":["stake-ica.contract.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;GAWG;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+H+3gD,QAAsB;;;;;GAJt6gD;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;kCA7K+B,aAAa;yBAAb,aAAa;6BAE5C,cAAc;4BAJN,kBAAkB;6CAC2B,uBAAuB;iCAMxE,0CAA0C;gCAC3C,0CAA0C;kCAHxC,cAAc;6BANnB,kBAAkB;2BAEmC,uBAAuB;mDAKtD,uBAAuB;gCAJd,aAAa;qCACpC,qBAAqB"}

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

@@ -0,0 +1,19 @@
+export const start: (zcf: ZCF<Record<string, unknown>>, privateArgs: OrchestrationPowers & {
+    marshaller: Remote<Marshaller>;
+}, baggage: import("@agoric/vat-data").Baggage) => Promise<{
+    publicFacet: import("@endo/exo").Guarded<{
+        makeAccount(): Promise<Invitation<import("@agoric/vow").Vow<import("../utils/zoe-tools.js").ResolvedContinuingOfferResult>, {
+            chainName: string;
+        }>>;
+    }>;
+    creatorFacet: import("@endo/exo").Guarded<{
+        registerChain(chainName: string, chainInfo: import("../orchestration-api.js").ChainInfo, ibcConnectionInfo?: import("../types.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 { Marshaller } from '@agoric/internal/src/lib-chainStorage.js';
+import type { Remote } from '@agoric/internal';
+import type { Invitation } from '@agoric/zoe';
+//# sourceMappingURL=staking-combinations.contract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"staking-combinations.contract.d.ts","sourceRoot":"","sources":["staking-combinations.contract.js"],"names":[],"mappings":"AAoKA;gBA5HiB,OAAO,UAAU,CAAC;;;;;;;;;;;GA4H4C;yBAhJtB,aAAa;yCAEZ,0BAA0B;gCAGvD,0CAA0C;4BAP9C,kBAAkB;gCAEc,aAAa"}

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

@@ -0,0 +1,32 @@
+export function makeAccount(orch: Orchestrator, ctx: {
+    makeCombineInvitationMakers: MakeCombineInvitationMakers;
+    makeExtraInvitationMaker: (account: any) => InvitationMakers;
+}, _seat: ZCFSeat, { chainName }: {
+    chainName: string;
+}): Promise<ResolvedContinuingOfferResult>;
+export function depositAndDelegate(_orch: Orchestrator, { chainHub, sharedLocalAccountP, zoeTools }: {
+    chainHub: GuestInterface<ChainHub>;
+    sharedLocalAccountP: Promise<GuestInterface<LocalOrchestrationAccountKit["holder"]>>;
+    zoeTools: GuestInterface<ZoeTools>;
+}, account: GuestInterface<CosmosOrchestrationAccount>, seat: ZCFSeat, validator: CosmosValidatorAddress): Promise<void>;
+export function undelegateAndTransfer(_orch: Orchestrator, _ctx: object, account: GuestInterface<CosmosOrchestrationAccount>, { delegations, destination }: {
+    delegations: {
+        amount: AmountArg;
+        validator: CosmosValidatorAddress;
+    }[];
+    destination: CosmosChainAddress;
+}): Promise<void>;
+import type { Orchestrator } from '../types.js';
+import type { MakeCombineInvitationMakers } from '../exos/combine-invitation-makers.js';
+import type { InvitationMakers } from '@agoric/smart-wallet/src/types.js';
+import type { ZCFSeat } from '@agoric/zoe';
+import type { ResolvedContinuingOfferResult } from '../utils/zoe-tools.js';
+import type { ChainHub } from '../types.js';
+import type { GuestInterface } from '@agoric/async-flow';
+import type { LocalOrchestrationAccountKit } from '../exos/local-orchestration-account.js';
+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';
+//# sourceMappingURL=staking-combinations.flows.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"staking-combinations.flows.d.ts","sourceRoot":"","sources":["staking-combinations.flows.js"],"names":[],"mappings":"AA6BO,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,0CAVI,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,6CATI,YAAY,QACZ,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;kCAnHmK,aAAa;iDAGnI,sCAAsC;sCAF1B,mCAAmC;6BAKnE,aAAa;mDADmB,uBAAuB;8BALmF,aAAa;oCADhJ,oBAAoB;kDAGN,wCAAwC;8BAG7B,uBAAuB;gDADpC,yCAAyC;4CAJ8E,aAAa;+BAAb,aAAa;wCAAb,aAAa"}