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

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

@@ -3,6 +3,8 @@ 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;
@@ -24,6 +26,7 @@ export const IcaAccountHolderI: import("@endo/patterns").InterfaceGuard<{
     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<{
@@ -38,8 +41,9 @@ export const CosmosOrchestrationInvitationMakersI: import("@endo/patterns").Inte
     SendAll: import("@endo/patterns").MethodGuard;
     Transfer: import("@endo/patterns").MethodGuard;
 }>;
-export function prepareCosmosOrchestrationAccountKit(zone: Zone, { chainHub, makeRecorderKit, timerService, vowTools: { watch, asVow, when, allVows }, zcf, }: {
+export function prepareCosmosOrchestrationAccountKit(zone: Zone, { chainHub, makeProgressTracker, makeRecorderKit, timerService, vowTools, zcf, }: {
     chainHub: ChainHub;
+    makeProgressTracker: MakeProgressTracker;
     makeRecorderKit: MakeRecorderKit;
     timerService: Remote<TimerService>;
     vowTools: VowTools;
@@ -50,10 +54,10 @@ export function prepareCosmosOrchestrationAccountKit(zone: Zone, { chainHub, mak
     remoteAddress: RemoteIbcAddress;
 }, io: {
     account: IcaAccount;
-    storageNode?: Remote<globalThis.StorageNode> | undefined;
+    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}`;
+        getRemoteAddress(): `/${string}ibc-port/${string}/unordered/${string}` | `/${string}ibc-port/${string}/ordered/${string}`;
         query(msgs: JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").RequestQuery>[]): Vow<JsonSafe<ResponseQuery>[]>;
     }> | undefined;
     timer: Remote<TimerService>;
@@ -67,6 +71,29 @@ export function prepareCosmosOrchestrationAccountKit(zone: Zone, { chainHub, mak
          * @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: {
         /**
@@ -100,12 +127,6 @@ export function prepareCosmosOrchestrationAccountKit(zone: Zone, { chainHub, mak
          */
         onFulfilled([result]: JsonSafe<ResponseQuery>[]): import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").UnbondingDelegation[];
     };
-    redelegationQueryWatcher: {
-        /**
-         * @param {JsonSafe<ResponseQuery>[]} results
-         */
-        onFulfilled([result]: JsonSafe<ResponseQuery>[]): import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").RedelegationResponse[];
-    };
     redelegationsQueryWatcher: {
         /**
          * @param {JsonSafe<ResponseQuery>[]} results
@@ -131,29 +152,48 @@ export function prepareCosmosOrchestrationAccountKit(zone: Zone, { chainHub, mak
          */
         onFulfilled([result]: JsonSafe<ResponseQuery>[]): import("../orchestration-api.js").DenomAmount[];
     };
-    undelegateWatcher: {
+    decodedUndelegateWatcher: {
         /**
-         * @param {string} result
+         * @param {readonly MsgUndelegateResponseType[]} responses
          */
-        onFulfilled(result: string): Vow<import("@agoric/time").TimestampRecord>;
+        onFulfilled(responses: readonly MsgUndelegateResponseType[]): Vow<import("@agoric/time").TimestampRecord>;
     };
     /**
-     * takes an array of results (from `executeEncodedTx`) and returns void
-     * since we are not interested in the result
+     * takes any arguments and returns void since we are not interested in the
+     * result
      */
     returnVoidWatcher: {
-        /** @param {string | Record<string, unknown>} result */
-        onFulfilled(result: string | Record<string, unknown>): undefined;
+        /**
+         * @param {unknown[]} args
+         * @returns {void}
+         */
+        onFulfilled(...args: unknown[]): void;
     };
-    withdrawRewardWatcher: {
-        /** @param {string} result */
-        onFulfilled(result: string): import("../orchestration-api.js").DenomAmount[];
+    decodedWithdrawRewardWatcher: {
+        /** @param {{ amount: Coin[] }} response */
+        onFulfilled(response: {
+            amount: Coin[];
+        }): import("../orchestration-api.js").DenomAmount[];
     };
-    transferWatcher: {
+    /**
+     * Decode responses based on the typeUrls of the original requests.
+     */
+    decodeResponsesWatcher: {
         /**
-         * @param {[
+         * @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,
+         *   bigint | undefined,
          * ]} results
          * @param {{
          *   destination: CosmosChainAddress;
@@ -161,28 +201,45 @@ export function prepareCosmosOrchestrationAccountKit(zone: Zone, { chainHub, mak
          *   token: Coin;
          * }} ctx
          */
-        onFulfilled([{ transferChannel }, timeoutTimestamp]: [{
+        onFulfilled([{ transferChannel }, timeoutTimestamp]: readonly [{
             transferChannel: IBCConnectionInfo["transferChannel"];
-        }, bigint], { opts, token, destination }: {
+        }, bigint | undefined], { opts, token, destination }: {
             destination: CosmosChainAddress;
             opts?: IBCMsgTransferOptions;
             token: Coin;
-        }): Vow<undefined>;
+        }): 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<Invitation<Vow<void>, undefined>>;
+        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<Invitation<Vow<void>, undefined>>;
+        Redelegate(srcValidator: CosmosValidatorAddress, dstValidator: CosmosValidatorAddress, amount: AmountArg): Promise<import("@agoric/zoe").Invitation<Vow<{}>, undefined>>;
         /** @param {CosmosValidatorAddress} validator */
-        WithdrawReward(validator: CosmosValidatorAddress): Promise<Invitation<Vow<import("../orchestration-api.js").DenomAmount[]>, undefined>>;
+        WithdrawReward(validator: CosmosValidatorAddress): Promise<import("@agoric/zoe").Invitation<Vow<{
+            denom: import("../orchestration-api.js").Denom;
+            value: bigint;
+        }[]>, undefined>>;
         /**
          * @param {{
          *   amount: AmountArg;
@@ -192,16 +249,18 @@ export function prepareCosmosOrchestrationAccountKit(zone: Zone, { chainHub, mak
         Undelegate(delegations: {
             amount: AmountArg;
             validator: CosmosValidatorAddress;
-        }[]): Promise<Invitation<Vow<void>, undefined>>;
-        DeactivateAccount(): Promise<Invitation<Vow<void>, undefined>>;
-        ReactivateAccount(): Promise<Invitation<Vow<void>, undefined>>;
-        Send(): Promise<Invitation<Vow<void>, {
+        }[]): 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<Invitation<Vow<void>, {
+        SendAll(): Promise<import("@agoric/zoe").Invitation<Vow<void>, {
             toAccount: CosmosChainAddress;
             amounts: AmountArg[];
+            opts?: CosmosActionOptions;
         }>>;
         /**
          * Starting a transfer revokes the account holder. The associated
@@ -209,35 +268,227 @@ export function prepareCosmosOrchestrationAccountKit(zone: Zone, { chainHub, mak
          * transferred.
          */
         TransferAccount(): never;
-        Transfer(): Promise<Invitation<Vow<void>, {
+        Transfer(): Promise<import("@agoric/zoe").Invitation<Vow<any>, {
             amount: AmountArg;
             destination: AccountIdArg;
             opts?: IBCMsgTransferOptions;
         }>>;
     };
     holder: {
-        asContinuingOffer(): Vow<import("@agoric/async-flow").HostInterface<import("../utils/zoe-tools.js").ResolvedContinuingOfferResult>>;
-        getPublicTopics(): Vow<import("@agoric/async-flow").HostInterface<Record<string, import("@agoric/zoe/src/contractSupport/topics.js").ResolvedPublicTopic<unknown>>>>;
-        getAddress(): import("@agoric/async-flow").HostInterface<CosmosChainAddress>;
-        delegate(validator: CosmosValidatorAddress, amount: AmountArg): Vow<void>;
-        redelegate(srcValidator: CosmosValidatorAddress, dstValidator: CosmosValidatorAddress, amount: AmountArg): Vow<void>;
-        withdrawReward(validator: CosmosValidatorAddress): Vow<import("../orchestration-api.js").DenomAmount[]>;
-        getBalance(denom: import("../orchestration-api.js").DenomArg): Vow<import("../orchestration-api.js").DenomAmount>;
-        getBalances(): Vow<import("../orchestration-api.js").DenomAmount[]>;
-        send(toAccount: AccountIdArg, amount: AmountArg): Vow<void>;
-        sendAll(toAccount: CosmosChainAddress, amounts: AmountArg[]): Vow<void>;
-        transfer(destination: AccountIdArg, amount: AmountArg, opts?: IBCMsgTransferOptions | undefined): Vow<void>;
-        transferSteps(amount: AmountArg, msg: import("../orchestration-api.js").TransferMsg): Vow<void>;
-        withdrawRewards(): Vow<import("../orchestration-api.js").DenomAmount[]>;
+        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;
-        }[]): Vow<void>;
+        }[], opts?: CosmosActionOptions | undefined): Vow<{}>;
         deactivate(): Vow<void>;
         reactivate(): Vow<void>;
-        getDelegation(validator: CosmosValidatorAddress): Vow<import("@agoric/async-flow").HostInterface<CosmosDelegationResponse>>;
-        getDelegations(): Vow<{
+        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;
@@ -250,65 +501,98 @@ export function prepareCosmosOrchestrationAccountKit(zone: Zone, { chainHub, mak
                     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";
             };
@@ -317,8 +601,22 @@ export function prepareCosmosOrchestrationAccountKit(zone: Zone, { chainHub, mak
                 value: bigint;
             };
         }[]>;
-        getUnbondingDelegation(validator: CosmosValidatorAddress): Vow<import("@agoric/async-flow").HostInterface<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").UnbondingDelegation>>;
-        getUnbondingDelegations(): Vow<{
+        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: {
@@ -333,7 +631,7 @@ export function prepareCosmosOrchestrationAccountKit(zone: Zone, { chainHub, mak
                 unbondingOnHoldRefCount: bigint;
             }[];
         }[]>;
-        getRedelegations(): Vow<{
+        getRedelegations(opts?: import("../cosmos-api.js").CosmosQuerierOptions | undefined): Vow<{
             redelegation: {
                 delegatorAddress: string;
                 validatorSrcAddress: string;
@@ -365,20 +663,228 @@ export function prepareCosmosOrchestrationAccountKit(zone: Zone, { chainHub, mak
                 balance: string;
             }[];
         }[]>;
-        getReward(validator: CosmosValidatorAddress): Vow<import("../orchestration-api.js").DenomAmount[]>;
-        getRewards(): Vow<import("@agoric/async-flow").HostInterface<CosmosRewardsResponse>>;
-        executeEncodedTx(msgs: {
+        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">> & {
-            sendOpts?: import("@agoric/network").SendOptions;
-        }) | undefined): Vow<string>;
-        depositForBurn(mintRecipient: `${string}:${string}:${string}`, amount: AmountArg, caller?: `${string}:${string}:${string}` | undefined): Vow<void>;
+        }[], 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, makeRecorderKit, timerService, vowTools, zcf }: {
+export function prepareCosmosOrchestrationAccount(zone: Zone, { chainHub, makeProgressTracker, makeRecorderKit, timerService, vowTools, zcf, }: {
     chainHub: ChainHub;
+    makeProgressTracker: MakeProgressTracker;
     makeRecorderKit: MakeRecorderKit;
     timerService: Remote<TimerService>;
     vowTools: VowTools;
@@ -407,6 +913,7 @@ export type CosmosOrchestrationAccountKit = ReturnType<ReturnType<typeof prepare
 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';
@@ -416,18 +923,28 @@ import type { CosmosChainAddress } from '../types.js';
 import type { LocalIbcAddress } from '@agoric/vats/tools/ibc-utils.js';
 import type { RemoteIbcAddress } from '@agoric/vats/tools/ibc-utils.js';
 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 '../types.js';
 import type { IBCMsgTransferOptions } from '../types.js';
 import type { CosmosValidatorAddress } from '../types.js';
-import type { Invitation } from '@agoric/zoe';
 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