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

package/src/exos/cosmos-orchestration-account.d.ts

@@ -0,0 +1,950 @@
+/** @see {OrchestrationAccountCommon} */
+export const IcaAccountHolderI: import("@endo/patterns").InterfaceGuard<{
+    deactivate: import("@endo/patterns").MethodGuard;
+    reactivate: import("@endo/patterns").MethodGuard;
+    executeEncodedTx: import("@endo/patterns").MethodGuard;
+    executeTxProto3: import("@endo/patterns").MethodGuard;
+    executeTxProto3Undecoded: import("@endo/patterns").MethodGuard;
+    getDelegation: import("@endo/patterns").MethodGuard;
+    getDelegations: import("@endo/patterns").MethodGuard;
+    getUnbondingDelegation: import("@endo/patterns").MethodGuard;
+    getUnbondingDelegations: import("@endo/patterns").MethodGuard;
+    getRedelegations: import("@endo/patterns").MethodGuard;
+    getReward: import("@endo/patterns").MethodGuard;
+    getRewards: import("@endo/patterns").MethodGuard;
+    delegate: import("@endo/patterns").MethodGuard;
+    redelegate: import("@endo/patterns").MethodGuard;
+    undelegate: import("@endo/patterns").MethodGuard;
+    withdrawReward: import("@endo/patterns").MethodGuard;
+    withdrawRewards: import("@endo/patterns").MethodGuard;
+    getAddress: import("@endo/patterns").MethodGuard;
+    getBalance: import("@endo/patterns").MethodGuard;
+    getBalances: import("@endo/patterns").MethodGuard;
+    send: import("@endo/patterns").MethodGuard;
+    sendAll: import("@endo/patterns").MethodGuard;
+    transfer: import("@endo/patterns").MethodGuard;
+    transferSteps: import("@endo/patterns").MethodGuard;
+    asContinuingOffer: import("@endo/patterns").MethodGuard;
+    getPublicTopics: import("@endo/patterns").MethodGuard;
+    makeProgressTracker: import("@endo/patterns").MethodGuard;
+    depositForBurn: import("@endo/patterns").MethodGuard;
+}>;
+export const CosmosOrchestrationInvitationMakersI: import("@endo/patterns").InterfaceGuard<{
+    Delegate: import("@endo/patterns").MethodGuard;
+    Redelegate: import("@endo/patterns").MethodGuard;
+    WithdrawReward: import("@endo/patterns").MethodGuard;
+    Undelegate: import("@endo/patterns").MethodGuard;
+    DeactivateAccount: import("@endo/patterns").MethodGuard;
+    ReactivateAccount: import("@endo/patterns").MethodGuard;
+    TransferAccount: import("@endo/patterns").MethodGuard;
+    Send: import("@endo/patterns").MethodGuard;
+    SendAll: import("@endo/patterns").MethodGuard;
+    Transfer: import("@endo/patterns").MethodGuard;
+}>;
+export function prepareCosmosOrchestrationAccountKit(zone: Zone, { chainHub, makeProgressTracker, makeRecorderKit, timerService, vowTools, zcf, }: {
+    chainHub: ChainHub;
+    makeProgressTracker: MakeProgressTracker;
+    makeRecorderKit: MakeRecorderKit;
+    timerService: Remote<TimerService>;
+    vowTools: VowTools;
+    zcf: ZCF;
+}): (args_0: {
+    chainAddress: CosmosChainAddress;
+    localAddress: LocalIbcAddress;
+    remoteAddress: RemoteIbcAddress;
+}, io: {
+    account: IcaAccount;
+    storageNode?: Remote<StorageNode> | undefined;
+    icqConnection?: import("@endo/exo").Guarded<{
+        getLocalAddress(): `/ibc-port/${string}`;
+        getRemoteAddress(): `/${string}ibc-port/${string}/ordered/${string}` | `/${string}ibc-port/${string}/unordered/${string}`;
+        query(msgs: JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").RequestQuery>[]): Vow<JsonSafe<ResponseQuery>[]>;
+    }> | undefined;
+    timer: Remote<TimerService>;
+}) => import("@endo/exo").GuardedKit<{
+    helper: {
+        /** @throws if this holder no longer owns the account */
+        owned(): IcaAccount;
+        getUpdater(): import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<CosmosOrchestrationAccountNotification>;
+        /**
+         * @param {AmountArg} amount
+         * @returns {Coin}
+         */
+        amountToCoin(amount: AmountArg): Coin;
+        pickVowProp<R extends readonly Record<PropertyKey, any>, K extends PropertyKey>(inputV: import("@agoric/vow").EVow<R>, prop: K): Vow<R[K]>;
+        pickVowIndex<T extends readonly unknown[], I extends number>(inputV: import("@agoric/vow").EVow<T>, index: I): Vow<T[I]>;
+        overrideVow<T = undefined>(inputV: Vow<unknown>, newValue?: T): Vow<T>;
+        voidVow(inputV: Vow<unknown>): Vow<void>;
+    };
+    updateTxProgressWatcher: {
+        /**
+         * @param {readonly [
+         *   srcChainInfo: ChainInfo<'cosmos'>,
+         *   la: LocalIbcAddress,
+         *   ra: RemoteIbcAddress,
+         * ]} param0
+         * @param {{
+         *   progressTracker: ProgressTracker;
+         *   trafficSlice: SliceDescriptor;
+         *   protocol: 'ibc';
+         * }} opts
+         */
+        onFulfilled([srcChainInfo, la, ra]: readonly [srcChainInfo: ChainInfo<"cosmos">, la: LocalIbcAddress, ra: RemoteIbcAddress], { progressTracker, trafficSlice, protocol }: {
+            progressTracker: ProgressTracker;
+            trafficSlice: SliceDescriptor;
+            protocol: "ibc";
+        }): void;
+    };
+    balanceQueryWatcher: {
+        /**
+         * @param {JsonSafe<ResponseQuery>[]} results
+         */
+        onFulfilled([result]: JsonSafe<ResponseQuery>[]): import("../orchestration-api.js").DenomAmount;
+    };
+    delegationQueryWatcher: {
+        /**
+         * @param {JsonSafe<ResponseQuery>[]} results
+         * @returns {CosmosDelegationResponse}
+         */
+        onFulfilled([result]: JsonSafe<ResponseQuery>[]): CosmosDelegationResponse;
+    };
+    delegationsQueryWatcher: {
+        /**
+         * @param {JsonSafe<ResponseQuery>[]} results
+         * @returns {CosmosDelegationResponse[]}
+         */
+        onFulfilled([result]: JsonSafe<ResponseQuery>[]): CosmosDelegationResponse[];
+    };
+    unbondingDelegationQueryWatcher: {
+        /**
+         * @param {JsonSafe<ResponseQuery>[]} results
+         */
+        onFulfilled([result]: JsonSafe<ResponseQuery>[]): import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").UnbondingDelegation;
+    };
+    unbondingDelegationsQueryWatcher: {
+        /**
+         * @param {JsonSafe<ResponseQuery>[]} results
+         */
+        onFulfilled([result]: JsonSafe<ResponseQuery>[]): import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").UnbondingDelegation[];
+    };
+    redelegationsQueryWatcher: {
+        /**
+         * @param {JsonSafe<ResponseQuery>[]} results
+         */
+        onFulfilled([result]: JsonSafe<ResponseQuery>[]): import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").RedelegationResponse[];
+    };
+    rewardQueryWatcher: {
+        /**
+         * @param {JsonSafe<ResponseQuery>[]} results
+         */
+        onFulfilled([result]: JsonSafe<ResponseQuery>[]): import("../orchestration-api.js").DenomAmount[];
+    };
+    rewardsQueryWatcher: {
+        /**
+         * @param {JsonSafe<ResponseQuery>[]} results
+         * @returns {CosmosRewardsResponse}
+         */
+        onFulfilled([result]: JsonSafe<ResponseQuery>[]): CosmosRewardsResponse;
+    };
+    allBalancesQueryWatcher: {
+        /**
+         * @param {JsonSafe<ResponseQuery>[]} results
+         */
+        onFulfilled([result]: JsonSafe<ResponseQuery>[]): import("../orchestration-api.js").DenomAmount[];
+    };
+    decodedUndelegateWatcher: {
+        /**
+         * @param {readonly MsgUndelegateResponseType[]} responses
+         */
+        onFulfilled(responses: readonly MsgUndelegateResponseType[]): Vow<import("@agoric/time").TimestampRecord>;
+    };
+    /**
+     * takes any arguments and returns void since we are not interested in the
+     * result
+     */
+    returnVoidWatcher: {
+        /**
+         * @param {unknown[]} args
+         * @returns {void}
+         */
+        onFulfilled(...args: unknown[]): void;
+    };
+    decodedWithdrawRewardWatcher: {
+        /** @param {{ amount: Coin[] }} response */
+        onFulfilled(response: {
+            amount: Coin[];
+        }): import("../orchestration-api.js").DenomAmount[];
+    };
+    /**
+     * Decode responses based on the typeUrls of the original requests.
+     */
+    decodeResponsesWatcher: {
+        /**
+         * @template {readonly (keyof TypeFromUrl | unknown)[]} [TUS=(keyof TypeFromUrl)[]]
+         * @param {string} resultStr
+         * @param {TUS} typeUrls
+         * @returns {{
+         *   [P in keyof TUS]: MessageBody<ResponseTypeUrl<TUS[P]>>;
+         * }}
+         */
+        onFulfilled<TUS extends readonly (keyof TypeFromUrl | unknown)[] = (keyof TypeFromUrl)[]>(resultStr: string, typeUrls: TUS): { [P in keyof TUS]: MessageBody<ResponseTypeUrl<TUS[P]>>; };
+    };
+    beginTransferWatcher: {
+        /**
+         * @param {readonly [
+         *   { transferChannel: IBCConnectionInfo['transferChannel'] },
+         *   bigint | undefined,
+         * ]} results
+         * @param {{
+         *   destination: CosmosChainAddress;
+         *   opts?: IBCMsgTransferOptions;
+         *   token: Coin;
+         * }} ctx
+         */
+        onFulfilled([{ transferChannel }, timeoutTimestamp]: readonly [{
+            transferChannel: IBCConnectionInfo["transferChannel"];
+        }, bigint | undefined], { opts, token, destination }: {
+            destination: CosmosChainAddress;
+            opts?: IBCMsgTransferOptions;
+            token: Coin;
+        }): Vow<string>;
+    };
+    fillSequenceWatcher: {
+        /**
+         * @param {[{ sequence: bigint }]} transferResponse
+         * @param {object} opts
+         * @param {ProgressTracker} opts.progressTracker
+         * @param {SliceDescriptor} opts.trafficSlice
+         */
+        onFulfilled([{ sequence }]: [{
+            sequence: bigint;
+        }], { progressTracker, trafficSlice }: {
+            progressTracker: ProgressTracker;
+            trafficSlice: SliceDescriptor;
+        }): void;
+    };
+    invitationMakers: {
+        /**
+         * @param {CosmosValidatorAddress} validator
+         * @param {AmountArg} amount
+         */
+        Delegate(validator: CosmosValidatorAddress, amount: AmountArg): Promise<import("@agoric/zoe").Invitation<Vow<{}>, undefined>>;
+        /**
+         * @param {CosmosValidatorAddress} srcValidator
+         * @param {CosmosValidatorAddress} dstValidator
+         * @param {AmountArg} amount
+         */
+        Redelegate(srcValidator: CosmosValidatorAddress, dstValidator: CosmosValidatorAddress, amount: AmountArg): Promise<import("@agoric/zoe").Invitation<Vow<{}>, undefined>>;
+        /** @param {CosmosValidatorAddress} validator */
+        WithdrawReward(validator: CosmosValidatorAddress): Promise<import("@agoric/zoe").Invitation<Vow<{
+            denom: import("../orchestration-api.js").Denom;
+            value: bigint;
+        }[]>, undefined>>;
+        /**
+         * @param {{
+         *   amount: AmountArg;
+         *   validator: CosmosValidatorAddress;
+         * }[]} delegations
+         */
+        Undelegate(delegations: {
+            amount: AmountArg;
+            validator: CosmosValidatorAddress;
+        }[]): Promise<import("@agoric/zoe").Invitation<Vow<{}>, undefined>>;
+        DeactivateAccount(): Promise<import("@agoric/zoe").Invitation<Vow<void>, undefined>>;
+        ReactivateAccount(): Promise<import("@agoric/zoe").Invitation<Vow<void>, undefined>>;
+        Send(): Promise<import("@agoric/zoe").Invitation<Vow<void>, {
+            toAccount: AccountIdArg;
+            amount: AmountArg;
+            opts?: CosmosActionOptions;
+        }>>;
+        SendAll(): Promise<import("@agoric/zoe").Invitation<Vow<void>, {
+            toAccount: CosmosChainAddress;
+            amounts: AmountArg[];
+            opts?: CosmosActionOptions;
+        }>>;
+        /**
+         * Starting a transfer revokes the account holder. The associated
+         * updater will get a special notification that the account is being
+         * transferred.
+         */
+        TransferAccount(): never;
+        Transfer(): Promise<import("@agoric/zoe").Invitation<Vow<any>, {
+            amount: AmountArg;
+            destination: AccountIdArg;
+            opts?: IBCMsgTransferOptions;
+        }>>;
+    };
+    holder: {
+        makeProgressTracker(): ProgressTracker;
+        asContinuingOffer(): Vow<{
+            invitationMakers: {
+                [x: string]: (...args: any[]) => 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) => Vow<{
+                            value: any;
+                            updateCount?: bigint | undefined | undefined;
+                        }>;
+                        subscribeAfter: (publishCount?: bigint | undefined) => 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(): Vow<{
+            [x: string]: {
+                description?: string | undefined;
+                subscriber: {
+                    getUpdateSince: (updateCount?: number | bigint | undefined) => Vow<{
+                        value: {};
+                        updateCount?: bigint | undefined | undefined;
+                    }>;
+                    subscribeAfter: (publishCount?: bigint | undefined) => 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("../cosmos-api.js").Bech32Address;
+            encoding: "bech32";
+        };
+        delegate(validator: CosmosValidatorAddress, amount: AmountArg, opts?: CosmosActionOptions | undefined): Vow<{}>;
+        redelegate(srcValidator: CosmosValidatorAddress, dstValidator: CosmosValidatorAddress, amount: AmountArg, opts?: CosmosActionOptions | undefined): Vow<{}>;
+        withdrawReward(validator: CosmosValidatorAddress, opts?: CosmosActionOptions | undefined): Vow<{
+            denom: import("../orchestration-api.js").Denom;
+            value: bigint;
+        }[]>;
+        getBalance(denom: import("../orchestration-api.js").DenomArg, opts?: import("../orchestration-api.js").QuerierOptions | undefined): Vow<{
+            denom: import("../orchestration-api.js").Denom;
+            value: bigint;
+        }>;
+        getBalances(opts?: import("../orchestration-api.js").QuerierOptions | undefined): Vow<{
+            denom: import("../orchestration-api.js").Denom;
+            value: bigint;
+        }[]>;
+        send(toAccount: AccountIdArg, amount: AmountArg, opts?: import("../orchestration-api.js").ActionOptions | undefined): Vow<{}>;
+        sendAll(toAccount: CosmosChainAddress, amounts: AmountArg[], opts?: import("../orchestration-api.js").ActionOptions | undefined): Vow<{}>;
+        transfer(destination: AccountIdArg, amount: AmountArg, opts?: IBCMsgTransferOptions | undefined): Vow<{}>;
+        transferSteps(amount: AmountArg, msg: import("../orchestration-api.js").TransferMsg): Vow<{}>;
+        withdrawRewards(opts?: CosmosActionOptions | undefined): Vow<{
+            denom: import("../orchestration-api.js").Denom;
+            value: bigint;
+        }[]>;
+        undelegate(delegations: {
+            amount: AmountArg;
+            delegator?: CosmosChainAddress;
+            validator: CosmosValidatorAddress;
+        }[], opts?: CosmosActionOptions | undefined): Vow<{}>;
+        deactivate(): Vow<void>;
+        reactivate(): Vow<void>;
+        getDelegation(validator: CosmosValidatorAddress, opts?: import("../cosmos-api.js").CosmosQuerierOptions | undefined): Vow<{
+            delegator: {
+                chainId: string;
+                value: import("../cosmos-api.js").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: import("../orchestration-api.js").Denom;
+                value: bigint;
+            };
+        }>;
+        getDelegations(opts?: import("../cosmos-api.js").CosmosQuerierOptions | undefined): Vow<{
+            delegator: {
+                chainId: string;
+                value: import("../cosmos-api.js").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: import("../orchestration-api.js").Denom;
+                value: bigint;
+            };
+        }[]>;
+        getUnbondingDelegation(validator: CosmosValidatorAddress, opts?: import("../cosmos-api.js").CosmosQuerierOptions | undefined): Vow<{
+            delegatorAddress: string;
+            validatorAddress: string;
+            entries: {
+                creationHeight: bigint;
+                completionTime: {
+                    seconds: bigint;
+                    nanos: number;
+                };
+                initialBalance: string;
+                balance: string;
+                unbondingId: bigint;
+                unbondingOnHoldRefCount: bigint;
+            }[];
+        }>;
+        getUnbondingDelegations(opts?: import("../cosmos-api.js").CosmosQuerierOptions | undefined): Vow<{
+            delegatorAddress: string;
+            validatorAddress: string;
+            entries: {
+                creationHeight: bigint;
+                completionTime: {
+                    seconds: bigint;
+                    nanos: number;
+                };
+                initialBalance: string;
+                balance: string;
+                unbondingId: bigint;
+                unbondingOnHoldRefCount: bigint;
+            }[];
+        }[]>;
+        getRedelegations(opts?: import("../cosmos-api.js").CosmosQuerierOptions | undefined): 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: CosmosValidatorAddress, opts?: import("../cosmos-api.js").CosmosQuerierOptions | undefined): Vow<{
+            denom: import("../orchestration-api.js").Denom;
+            value: bigint;
+        }[]>;
+        getRewards(opts?: import("../cosmos-api.js").CosmosQuerierOptions | undefined): 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: import("../orchestration-api.js").Denom;
+                    value: bigint;
+                }[];
+            }[];
+            total: {
+                denom: import("../orchestration-api.js").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<CosmosActionOptions, "txOpts">) | undefined): Vow<string>;
+        executeTxProto3Undecoded(msgs: readonly {
+            $typeUrl?: "/google.protobuf.Any" | string | undefined;
+            typeUrl: string;
+            value: string;
+        }[], opts?: CosmosActionOptions | undefined): Vow<string>;
+        /**
+         * @template {readonly (keyof TypeFromUrl | unknown)[]} TUS
+         * @param {{
+         *   readonly [K in keyof TUS]: AnyJson<TUS[K]>;
+         * }} msgs
+         * @param {CosmosActionOptions} [opts]
+         * @returns {Vow<{
+         *   [K in keyof TUS]: MessageBody<ResponseTypeUrl<TUS[K]>>;
+         * }>}
+         */
+        executeTxProto3<TUS extends readonly (keyof TypeFromUrl | unknown)[]>(msgs: { readonly [K in keyof TUS]: AnyJson<TUS[K]>; }, opts?: CosmosActionOptions): Vow<{ [K in keyof TUS]: MessageBody<ResponseTypeUrl<TUS[K]>>; }>;
+        depositForBurn(mintRecipient: `${string}:${string}:${string}`, amount: AmountArg, caller?: `${string}:${string}:${string}` | undefined, opts?: CosmosActionOptions | undefined): Vow<{}>;
+    };
+    pickDataWatcher: {
+        onFulfilled<V extends {}, K extends keyof V>(value: V, key: K): V[K];
+    };
+    overrideVowWatcher: {
+        onFulfilled<V>(_value: unknown, newValue: V): V;
+    };
+    transferWatcher: {
+        onFulfilled: () => never;
+    };
+    redelegationQueryWatcher: {
+        onFulfilled: () => never;
+    };
+    /** @deprecated only used by obsolete *WithMeta methods */
+    attachTxMetaWatcher: {
+        /**
+         * TODO(#1994): Subsume with IcaAccount.executeEncodedTxWithMeta().
+         *
+         * @param {readonly [
+         *   agoric: ChainInfo<'cosmos'>,
+         *   la: LocalIbcAddress,
+         *   counterparty: CaipChainId,
+         *   ra: RemoteIbcAddress,
+         * ]} _param0
+         * @param {{ result: Vow<any>; meta: Record<string, any> }} param1
+         * @param {string} _protocol
+         */
+        onFulfilled(_param0: readonly [agoric: ChainInfo<"cosmos">, la: LocalIbcAddress, counterparty: CaipChainId, ra: RemoteIbcAddress], { result, meta }: {
+            result: Vow<any>;
+            meta: Record<string, any>;
+        }, _protocol: string): {
+            result: Vow<any>;
+            meta: Record<string, any>;
+        };
+    };
+    /** @deprecated only used by obsolete *WithMeta methods */
+    parseTransferWatcher: {
+        onFulfilled(): {
+            result: Vow<null>;
+            meta: {};
+        };
+    };
+    /** @deprecated only used by obsolete *WithMeta methods */
+    transferWithMetaWatcher: {
+        /**
+         * @param {readonly [
+         *   { transferChannel: IBCConnectionInfo['transferChannel'] },
+         *   bigint | undefined,
+         * ]} results
+         * @param {{
+         *   destination: CosmosChainAddress;
+         *   opts?: IBCMsgTransferOptions;
+         *   token: Coin;
+         * }} ctx
+         */
+        onFulfilled(results: readonly [{
+            transferChannel: IBCConnectionInfo["transferChannel"];
+        }, bigint | undefined], ctx: {
+            destination: CosmosChainAddress;
+            opts?: IBCMsgTransferOptions;
+            token: Coin;
+        }): {
+            result: Vow<string>;
+            meta: {};
+        };
+    };
+    /** @deprecated only used before executeTxProto3 */
+    undelegateWatcher: {
+        /**
+         * @param {string} txResult
+         */
+        onFulfilled(txResult: string): Vow<import("@agoric/time").TimestampRecord>;
+    };
+    /** @deprecated only used before executeTxProto3 */
+    withdrawRewardWatcher: {
+        /** @param {string} result */
+        onFulfilled(result: string): import("../orchestration-api.js").DenomAmount[];
+    };
+}>;
+export function prepareCosmosOrchestrationAccount(zone: Zone, { chainHub, makeProgressTracker, makeRecorderKit, timerService, vowTools, zcf, }: {
+    chainHub: ChainHub;
+    makeProgressTracker: MakeProgressTracker;
+    makeRecorderKit: MakeRecorderKit;
+    timerService: Remote<TimerService>;
+    vowTools: VowTools;
+    zcf: ZCF;
+}): (...args: Parameters<ReturnType<typeof prepareCosmosOrchestrationAccountKit>>) => CosmosOrchestrationAccountKit["holder"];
+export type CosmosOrchestrationAccountNotification = {
+    chainAddress: CosmosChainAddress;
+};
+/**
+ * Internal to the IcaAccountHolder exo
+ */
+export type State = {
+    account: IcaAccount;
+    chainAddress: CosmosChainAddress;
+    icqConnection: ICQConnection | undefined;
+    localAddress: LocalIbcAddress;
+    remoteAddress: RemoteIbcAddress;
+    timer: Remote<TimerService>;
+    topicKit: RecorderKit<CosmosOrchestrationAccountNotification> | undefined;
+};
+export type CosmosOrchestrationAccountStorageState = {
+    localAddress: LocalIbcAddress;
+    remoteAddress: RemoteIbcAddress;
+};
+export type CosmosOrchestrationAccountKit = ReturnType<ReturnType<typeof prepareCosmosOrchestrationAccountKit>>;
+export type CosmosOrchestrationAccount = CosmosOrchestrationAccountKit["holder"];
+import type { Zone } from '@agoric/zone';
+import type { ChainHub } from '../types.js';
+import type { MakeProgressTracker } from '../types.js';
+import type { MakeRecorderKit } from '@agoric/zoe/src/contractSupport/recorder.js';
+import type { TimerService } from '@agoric/time';
+import type { Remote } from '@agoric/internal';
+import type { VowTools } from '@agoric/vow';
+import type { ZCF } from '@agoric/zoe';
+import type { CosmosChainAddress } from '../types.js';
+import type { LocalIbcAddress } from '@agoric/network/ibc';
+import type { RemoteIbcAddress } from '@agoric/network/ibc';
+import type { IcaAccount } from '../types.js';
+import type { StorageNode } from '@agoric/internal/src/lib-chainStorage.js';
+import type { JsonSafe } from '@agoric/cosmic-proto';
+import type { ResponseQuery } from '@agoric/cosmic-proto/tendermint/abci/types.js';
+import type { Vow } from '@agoric/vow';
+import type { AmountArg } from '../types.js';
+import type { Coin } from '@agoric/cosmic-proto/cosmos/base/v1beta1/coin.js';
+import type { ChainInfo } from '../types.js';
+import type { ProgressTracker } from '../types.js';
+import type { SliceDescriptor } from '../utils/orchestrationAccount.js';
+import type { CosmosDelegationResponse } from '../types.js';
+import type { CosmosRewardsResponse } from '../types.js';
+import type { MsgUndelegateResponseType } from '../utils/codecs.js';
+import type { TypeFromUrl } from '@agoric/cosmic-proto';
+import type { ResponseTypeUrl } from '@agoric/cosmic-proto';
+import type { MessageBody } from '@agoric/cosmic-proto';
+import type { IBCConnectionInfo } from '@agoric/network/ibc';
+import type { IBCMsgTransferOptions } from '../types.js';
+import type { CosmosValidatorAddress } from '../types.js';
+import type { AccountIdArg } from '../types.js';
+import type { CosmosActionOptions } from '../types.js';
+import type { AnyJson } from '@agoric/cosmic-proto';
+import type { CaipChainId } from '../types.js';
+import type { ICQConnection } from '../types.js';
+import type { RecorderKit } from '@agoric/zoe/src/contractSupport/recorder.js';
+//# sourceMappingURL=cosmos-orchestration-account.d.ts.map