@swapkit/toolboxes 4.28.4 → 5.1.0

package/dist/types/cosmos/thorchainUtils/messages.d.ts

@@ -62,7 +62,10 @@ export declare const buildAminoMsg: ({ sender, recipient, assetValue, memo, }: {
         to_address: string | undefined;
     };
 };
-export declare const convertToSignable: (msg: MsgSend | MsgDeposit, chain: TCLikeChain) => Promise<import("@cosmjs/proto-signing/build").EncodeObject>;
+export declare const convertToSignable: (msg: MsgSend | MsgDeposit, chain: TCLikeChain) => {
+    typeUrl: string;
+    value: unknown;
+};
 export declare function createTransaction(params: ThorchainCreateTransactionParams): Promise<{
     accountNumber: number;
     chainId: import("@swapkit/types").ChainId.Maya | import("@swapkit/types").ChainId.THORChain;
@@ -74,7 +77,7 @@ export declare function createTransaction(params: ThorchainCreateTransactionPara
         gas: string;
     };
     memo: string;
-    msgs: (import("@cosmjs/proto-signing/build").EncodeObject | {
+    msgs: ({
         type: "thorchain/MsgSend" | "mayachain/MsgSend";
         value: {
             amount: {
@@ -84,6 +87,9 @@ export declare function createTransaction(params: ThorchainCreateTransactionPara
             from_address: string;
             to_address: string | undefined;
         };
+    } | {
+        typeUrl: string;
+        value: unknown;
     })[];
     sequence: number;
 } | {
@@ -97,7 +103,7 @@ export declare function createTransaction(params: ThorchainCreateTransactionPara
         gas: string;
     };
     memo: string;
-    msgs: (import("@cosmjs/proto-signing/build").EncodeObject | {
+    msgs: ({
         type: "thorchain/MsgDeposit" | "mayachain/MsgDeposit";
         value: {
             coins: {
@@ -107,6 +113,9 @@ export declare function createTransaction(params: ThorchainCreateTransactionPara
             memo: string;
             signer: string;
         };
+    } | {
+        typeUrl: string;
+        value: unknown;
     })[];
     sequence: number;
 }>;
@@ -122,7 +131,7 @@ export declare function buildTransferTx({ sender, recipient, assetValue, memo, a
         gas: string;
     };
     memo: string;
-    msgs: (import("@cosmjs/proto-signing/build").EncodeObject | {
+    msgs: ({
         type: "thorchain/MsgSend" | "mayachain/MsgSend";
         value: {
             amount: {
@@ -132,6 +141,9 @@ export declare function buildTransferTx({ sender, recipient, assetValue, memo, a
             from_address: string;
             to_address: string | undefined;
         };
+    } | {
+        typeUrl: string;
+        value: unknown;
     })[];
     sequence: number;
 }>;
@@ -146,7 +158,7 @@ export declare function buildDepositTx({ sender, assetValue, memo, asSignable, a
         gas: string;
     };
     memo: string;
-    msgs: (import("@cosmjs/proto-signing/build").EncodeObject | {
+    msgs: ({
         type: "thorchain/MsgDeposit" | "mayachain/MsgDeposit";
         value: {
             coins: {
@@ -156,6 +168,9 @@ export declare function buildDepositTx({ sender, assetValue, memo, asSignable, a
             memo: string;
             signer: string;
         };
+    } | {
+        typeUrl: string;
+        value: unknown;
     })[];
     sequence: number;
 }>;
@@ -200,9 +215,18 @@ export declare function parseAminoMessageForDirectSigning<T extends MsgDeposit |
         to_address: string | undefined;
     };
 });
+/**
+ * Encode the TxBody for a THORChain/Maya transaction. Mirrors the cosmjs
+ * `Registry.encode({ typeUrl: "/cosmos.tx.v1beta1.TxBody", value: ... })`
+ * behaviour but uses our cosmos-signer encoder map + `encodeTxBody`.
+ *
+ * Each inner message is first converted from amino → direct (via the amino
+ * converter map's `fromAmino`), then encoded with the per-typeUrl encoder
+ * registered in `createDefaultRegistry`.
+ */
 export declare function buildEncodedTxBody({ chain, memo, msgs, }: {
     msgs: DirectMsgDepositForBroadcast[] | DirectMsgSendForBroadcast[];
     memo: string;
     chain: TCLikeChain;
-}): Promise<Uint8Array<ArrayBuffer>>;
+}): Uint8Array;
 export {};

package/dist/types/cosmos/thorchainUtils/registry.d.ts

@@ -1,3 +1,73 @@
+import { type EncoderMap } from "@swapkit/cosmos-signer";
 import { type TCLikeChain } from "@swapkit/helpers";
-export declare function createDefaultRegistry(): Promise<import("@cosmjs/proto-signing/build").Registry>;
-export declare function createDefaultAminoTypes(chain: TCLikeChain, addressPrefix?: string): Promise<import("@cosmjs/stargate/build").AminoTypes>;
+/**
+ * Per-typeUrl encoder map for THORChain / Maya. Merges with `defaultEncoders`
+ * (which provides `/cosmos.bank.v1beta1.MsgSend`).
+ */
+export declare function createDefaultRegistry(): EncoderMap;
+/**
+ * Amino converter map for THORChain / Maya. Lookup is by `typeUrl`. Each
+ * entry exposes both `fromAmino` (amino value → direct value) and
+ * `toAmino` (direct value → amino value).
+ */
+export declare function createDefaultAminoTypes(chain: TCLikeChain, addressPrefix?: string): {
+    readonly "/types.MsgDeposit": {
+        readonly aminoType: "thorchain/MsgDeposit" | "mayachain/MsgDeposit";
+        readonly fromAmino: ({ signer, ...rest }: {
+            signer: string;
+            [key: string]: unknown;
+        }) => {
+            signer: string;
+        };
+        readonly toAmino: ({ signer, ...rest }: {
+            signer: unknown;
+            [key: string]: unknown;
+        }) => {
+            signer: unknown;
+        };
+    };
+    readonly "/types.MsgSend": {
+        readonly aminoType: "thorchain/MsgSend" | "mayachain/MsgSend";
+        readonly fromAmino: ({ from_address, to_address, ...rest }: {
+            from_address: string;
+            to_address: string;
+            [key: string]: unknown;
+        }) => {
+            fromAddress: string;
+            toAddress: string;
+        };
+        readonly toAmino: ({ fromAddress, toAddress, ...rest }: {
+            fromAddress: unknown;
+            toAddress: unknown;
+            [key: string]: unknown;
+        }) => {
+            from_address: unknown;
+            to_address: unknown;
+        };
+    };
+} & {
+    fromAmino(message: {
+        type: string;
+        value: unknown;
+    }): {
+        typeUrl: string;
+        value: {
+            signer: string;
+        } | {
+            fromAddress: string;
+            toAddress: string;
+        };
+    };
+    toAmino(message: {
+        typeUrl: string;
+        value: unknown;
+    }): {
+        type: "thorchain/MsgDeposit" | "mayachain/MsgDeposit" | "thorchain/MsgSend" | "mayachain/MsgSend";
+        value: {
+            signer: unknown;
+        } | {
+            from_address: unknown;
+            to_address: unknown;
+        };
+    };
+};

package/dist/types/cosmos/thorchainUtils/types/client-types.d.ts

@@ -1,6 +1,11 @@
-import type { EncodeObject } from "@cosmjs/proto-signing";
+import type { Message } from "@swapkit/cosmos-signer";
 import type { Asset, ChainId, GenericTransferParams } from "@swapkit/helpers";
 import type { CosmosCreateTransactionParams } from "../../types";
+/**
+ * Local replacement for cosmjs `EncodeObject` — same `{ typeUrl, value }`
+ * shape, sourced from cosmos-signer's `Message<unknown>`.
+ */
+export type EncodeObject = Message<unknown>;
 declare enum TxType {
     Transfer = "transfer",
     Unknown = "unknown"

package/dist/types/cosmos/toolbox/cosmos.d.ts

@@ -1,9 +1,7 @@
-import type { Account } from "@cosmjs/stargate";
 import { AssetValue, Chain, type ChainId, type CosmosChain, type DerivationPathArray, type GenericTransferParams, SwapKitNumber } from "@swapkit/helpers";
 import { type CosmosTransaction } from "@swapkit/helpers/api";
-import type { TxRaw } from "cosmjs-types/cosmos/tx/v1beta1/tx";
-import type { CosmosToolboxParams } from "../types";
-import { cosmosCreateTransaction } from "../util";
+import type { CosmosToolboxParams, OfflineDirectSigner } from "../types";
+import { type Account, cosmosCreateTransaction, type SignedTx } from "../util";
 export declare function fetchFeeRateFromSwapKit(chainId: ChainId, safeDefault: number): Promise<number>;
 export declare function getSignerFromPhrase({ phrase, prefix, ...derivationParams }: {
     phrase: string;
@@ -13,21 +11,21 @@ export declare function getSignerFromPhrase({ phrase, prefix, ...derivationParam
     index?: number;
 } | {
     derivationPath: string;
-})): Promise<import("@cosmjs/proto-signing/build").DirectSecp256k1HdWallet>;
+})): Promise<OfflineDirectSigner>;
 export declare function getSignerFromPrivateKey({ privateKey, prefix }: {
     privateKey: Uint8Array;
     prefix: string;
-}): Promise<import("@cosmjs/proto-signing/build").DirectSecp256k1Wallet>;
+}): Promise<OfflineDirectSigner>;
 export declare function verifySignature(getAccount: (address: string) => Promise<Account | null>): ({ signature, message, address, }: {
     signature: string;
     message: string;
     address: string;
 }) => Promise<boolean>;
 export declare function createCosmosToolbox({ chain, ...toolboxParams }: CosmosToolboxParams): {
-    createPrivateKeyFromPhrase: (phrase: string) => Promise<Uint8Array<ArrayBufferLike>>;
+    createPrivateKeyFromPhrase: (phrase: string) => Promise<Uint8Array<ArrayBuffer>>;
     createTransaction: typeof cosmosCreateTransaction;
     fetchFeeRateFromSwapKit: typeof fetchFeeRateFromSwapKit;
-    getAccount: (address: string) => Promise<Account | null>;
+    getAccount: (address: string) => Promise<import("..").StargateAccount | null>;
     getAddress: () => Promise<string | undefined>;
     getBalance: (address: string, _potentialScamFilter?: boolean) => Promise<AssetValue[]>;
     getBalanceAsDenoms: (address: string) => Promise<{
@@ -43,10 +41,10 @@ export declare function createCosmosToolbox({ chain, ...toolboxParams }: CosmosT
     getSignerFromPhrase: ({ phrase, derivationPath }: {
         phrase: string;
         derivationPath: DerivationPathArray;
-    }) => Promise<import("@cosmjs/proto-signing/build").DirectSecp256k1HdWallet>;
-    getSignerFromPrivateKey: (privateKey: Uint8Array) => Promise<import("@cosmjs/proto-signing/build").DirectSecp256k1Wallet>;
+    }) => Promise<OfflineDirectSigner>;
+    getSignerFromPrivateKey: (privateKey: Uint8Array) => Promise<OfflineDirectSigner>;
     signAndBroadcastTransaction: (transaction: CosmosTransaction) => Promise<string>;
-    signTransaction: (transaction: CosmosTransaction) => Promise<TxRaw>;
+    signTransaction: (transaction: CosmosTransaction) => Promise<SignedTx>;
     transfer: ({ recipient, assetValue, memo, feeRate, feeOptionKey, sweep, }: GenericTransferParams) => Promise<string>;
     validateAddress: (address: string) => boolean;
     verifySignature: ({ signature, message, address, }: {

package/dist/types/cosmos/toolbox/thorchain.d.ts

@@ -1,9 +1,15 @@
-import type { Pubkey, Secp256k1HdWallet } from "@cosmjs/amino";
+import { type MultisigThresholdPubkey, type SinglePubkey } from "@swapkit/cosmos-signer";
 import { type GenericTransferParams, type TCLikeChain } from "@swapkit/helpers";
 import type { CosmosTransaction } from "@swapkit/helpers/api";
 import { buildEncodedTxBody, createDefaultRegistry, createTransaction, parseAminoMessageForDirectSigning } from "../thorchainUtils";
-import type { CosmosToolboxParams, MultiSigSigner, MultisigTx } from "../types";
-declare function createMultisig(pubKeys: string[], threshold: number, noSortPubKeys?: boolean): Promise<import("@cosmjs/amino/build").MultisigThresholdPubkey>;
+import type { CosmosToolboxParams, LocalAminoSigner, MultiSigSigner, MultisigTx } from "../types";
+/**
+ * Amino-signing wallet wrapper that mirrors the cosmjs `Secp256k1HdWallet`
+ * shape consumed by the multisig flow: exposes `getAccounts()` + `signAmino()`
+ * with the StdSignature shape downstream callers expect.
+ */
+type Secp256k1HdWalletLike = LocalAminoSigner;
+declare function createMultisig(pubKeys: string[], threshold: number, noSortPubKeys?: boolean): MultisigThresholdPubkey;
 declare function importSignature(signature: string): Uint8Array<ArrayBufferLike>;
 declare function signWithPrivateKey({ privateKey, message }: {
     privateKey: Uint8Array;
@@ -58,8 +64,71 @@ export declare function createThorchainToolbox({ chain, ...toolboxParams }: Cosm
             memo: string;
             signer: string;
         };
-    }, chain: TCLikeChain) => Promise<import("@cosmjs/proto-signing/build").EncodeObject>;
-    createDefaultAminoTypes: () => Promise<import("@cosmjs/stargate/build").AminoTypes>;
+    }, chain: TCLikeChain) => {
+        typeUrl: string;
+        value: unknown;
+    };
+    createDefaultAminoTypes: () => {
+        readonly "/types.MsgDeposit": {
+            readonly aminoType: "thorchain/MsgDeposit" | "mayachain/MsgDeposit";
+            readonly fromAmino: ({ signer, ...rest }: {
+                signer: string;
+                [key: string]: unknown;
+            }) => {
+                signer: string;
+            };
+            readonly toAmino: ({ signer, ...rest }: {
+                signer: unknown;
+                [key: string]: unknown;
+            }) => {
+                signer: unknown;
+            };
+        };
+        readonly "/types.MsgSend": {
+            readonly aminoType: "thorchain/MsgSend" | "mayachain/MsgSend";
+            readonly fromAmino: ({ from_address, to_address, ...rest }: {
+                from_address: string;
+                to_address: string;
+                [key: string]: unknown;
+            }) => {
+                fromAddress: string;
+                toAddress: string;
+            };
+            readonly toAmino: ({ fromAddress, toAddress, ...rest }: {
+                fromAddress: unknown;
+                toAddress: unknown;
+                [key: string]: unknown;
+            }) => {
+                from_address: unknown;
+                to_address: unknown;
+            };
+        };
+    } & {
+        fromAmino(message: {
+            type: string;
+            value: unknown;
+        }): {
+            typeUrl: string;
+            value: {
+                signer: string;
+            } | {
+                fromAddress: string;
+                toAddress: string;
+            };
+        };
+        toAmino(message: {
+            typeUrl: string;
+            value: unknown;
+        }): {
+            type: "thorchain/MsgDeposit" | "mayachain/MsgDeposit" | "thorchain/MsgSend" | "mayachain/MsgSend";
+            value: {
+                signer: unknown;
+            } | {
+                from_address: unknown;
+                to_address: unknown;
+            };
+        };
+    };
     createDefaultRegistry: typeof createDefaultRegistry;
     createMultisig: typeof createMultisig;
     createTransaction: typeof createTransaction;
@@ -73,24 +142,24 @@ export declare function createThorchainToolbox({ chain, ...toolboxParams }: Cosm
     }>;
     importSignature: typeof importSignature;
     parseAminoMessageForDirectSigning: typeof parseAminoMessageForDirectSigning;
-    pubkeyToAddress: (pubkey: Pubkey) => Promise<string>;
-    secp256k1HdWalletFromMnemonic: (mnemonic: string, index?: number) => Promise<Secp256k1HdWallet>;
+    pubkeyToAddress: (pubkey: SinglePubkey | MultisigThresholdPubkey) => string;
+    secp256k1HdWalletFromMnemonic: (mnemonic: string, index?: number) => Promise<Secp256k1HdWalletLike>;
     signAndBroadcastTransaction: ({ fee, memo, msgs }: Pick<CosmosTransaction, "fee" | "memo" | "msgs">) => Promise<string>;
     signMultisigTx: ({ wallet, tx }: {
-        wallet: Secp256k1HdWallet;
+        wallet: Secp256k1HdWalletLike;
         tx: string | MultisigTx;
     }) => Promise<{
-        bodyBytes: Uint8Array<ArrayBuffer>;
+        bodyBytes: Uint8Array<ArrayBufferLike>;
         signature: string;
     }>;
-    signTransaction: (transaction: CosmosTransaction) => Promise<import("cosmjs-types/cosmos/tx/v1beta1/tx").TxRaw>;
+    signTransaction: (transaction: CosmosTransaction) => Promise<import("..").SignedTx>;
     signWithPrivateKey: typeof signWithPrivateKey;
     transfer: ({ assetValue, memo, recipient, sweep, }: Omit<GenericTransferParams, "recipient"> & {
         recipient?: string;
     }) => Promise<string>;
-    createPrivateKeyFromPhrase: (phrase: string) => Promise<Uint8Array<ArrayBufferLike>>;
+    createPrivateKeyFromPhrase: (phrase: string) => Promise<Uint8Array<ArrayBuffer>>;
     fetchFeeRateFromSwapKit: typeof import("./cosmos").fetchFeeRateFromSwapKit;
-    getAccount: (address: string) => Promise<import("@cosmjs/stargate/build").Account | null>;
+    getAccount: (address: string) => Promise<import("..").StargateAccount | null>;
     getAddress: () => Promise<string | undefined>;
     getBalance: (address: string, _potentialScamFilter?: boolean) => Promise<import("@swapkit/helpers").AssetValue[]>;
     getBalanceAsDenoms: (address: string) => Promise<{
@@ -101,8 +170,8 @@ export declare function createThorchainToolbox({ chain, ...toolboxParams }: Cosm
     getSignerFromPhrase: ({ phrase, derivationPath }: {
         phrase: string;
         derivationPath: import("@swapkit/helpers").DerivationPathArray;
-    }) => Promise<import("@cosmjs/proto-signing/build").DirectSecp256k1HdWallet>;
-    getSignerFromPrivateKey: (privateKey: Uint8Array) => Promise<import("@cosmjs/proto-signing/build").DirectSecp256k1Wallet>;
+    }) => Promise<import("..").OfflineDirectSigner>;
+    getSignerFromPrivateKey: (privateKey: Uint8Array) => Promise<import("..").OfflineDirectSigner>;
     validateAddress: (address: string) => boolean;
     verifySignature: ({ signature, message, address, }: {
         signature: string;

package/dist/types/cosmos/types.d.ts

@@ -1,5 +1,4 @@
-import type { OfflineAminoSigner } from "@cosmjs/amino";
-import type { DirectSecp256k1HdWallet, OfflineDirectSigner } from "@cosmjs/proto-signing";
+import type { StdSignDoc } from "@swapkit/cosmos-signer";
 import type { ChainId, CosmosChain, DerivationPathArray, GenericCreateTransactionParams, TCLikeChain } from "@swapkit/helpers";
 import type { buildAminoMsg } from "./thorchainUtils";
 import type { createCosmosToolbox } from "./toolbox/cosmos";
@@ -27,7 +26,74 @@ export type MultisigTx = {
     fee: ReturnType<typeof getDefaultChainFee>;
     memo: string;
 };
-export type CosmosSigner = DirectSecp256k1HdWallet | OfflineDirectSigner | OfflineAminoSigner;
+/**
+ * Account data returned by signers (matches the cosmjs `AccountData` shape that
+ * external wallet adapters — Keplr, Leap, Ledger — already produce).
+ */
+export type AccountData = {
+    address: string;
+    algo: string;
+    pubkey: Uint8Array;
+};
+/**
+ * StdSignature shape (matches `@cosmjs/amino`): used by Keplr-style adapters
+ * to return amino signatures.
+ */
+export type StdSignature = {
+    pub_key: {
+        type: string;
+        value: string;
+    };
+    signature: string;
+};
+/**
+ * SignDoc shape for `SIGN_MODE_DIRECT`. Mirrors `@cosmjs/proto-signing`
+ * `SignDoc` — external wallet adapters that already speak the cosmjs API
+ * satisfy this shape unchanged.
+ */
+export type DirectSignDoc = {
+    bodyBytes: Uint8Array;
+    authInfoBytes: Uint8Array;
+    chainId: string;
+    accountNumber: bigint;
+};
+/**
+ * Offline signer for `SIGN_MODE_DIRECT` (Keplr-direct, Leap-direct, local
+ * cosmos-signer wrapper). Replaces `@cosmjs/proto-signing` `OfflineDirectSigner`.
+ */
+export interface OfflineDirectSigner {
+    getAccounts(): Promise<readonly AccountData[]>;
+    signDirect(signerAddress: string, signDoc: DirectSignDoc): Promise<{
+        signed: DirectSignDoc;
+        signature: StdSignature;
+    }>;
+}
+/**
+ * Offline signer for `SIGN_MODE_LEGACY_AMINO_JSON` (Keplr-amino, Leap-amino,
+ * Ledger, local amino wrappers). Replaces `@cosmjs/amino` `OfflineAminoSigner`.
+ */
+export interface OfflineAminoSigner {
+    getAccounts(): Promise<readonly AccountData[]>;
+    signAmino(signerAddress: string, signDoc: StdSignDoc): Promise<{
+        signed: StdSignDoc;
+        signature: StdSignature;
+    }>;
+}
+/**
+ * Either an amino-mode signer or a direct-mode signer. External wallets
+ * implement one of the two — the toolbox detects via `"signAmino" in signer`.
+ */
+export type OfflineSigner = OfflineDirectSigner | OfflineAminoSigner;
+/**
+ * Convenience alias matching the legacy cosmjs `Secp256k1HdWallet` shape.
+ * Our `createSecp256k1HdWallet` returns this — a local amino signer + the
+ * underlying mnemonic-derived key material exposed for the multisig
+ * combiner that needs the pubkey.
+ */
+export type LocalAminoSigner = OfflineAminoSigner & {
+    readonly accounts?: readonly AccountData[];
+};
+export type CosmosSigner = OfflineDirectSigner | OfflineAminoSigner;
 export type CosmosToolboxParams<T = CosmosChain> = {
     chain: T;
 } & ({

package/dist/types/cosmos/util.d.ts

@@ -1,7 +1,6 @@
-import type { OfflineSigner } from "@cosmjs/proto-signing";
-import type { SigningStargateClientOptions } from "@cosmjs/stargate";
+import { type EncoderMap } from "@swapkit/cosmos-signer";
 import { AssetValue, type CosmosChain, SwapKitNumber, type TCLikeChain } from "@swapkit/helpers";
-import type { CosmosCreateTransactionParams } from "./types";
+import type { CosmosCreateTransactionParams, OfflineSigner } from "./types";
 export declare const USK_KUJIRA_FACTORY_DENOM = "FACTORY/KUJIRA1QK00H5ATUTPSV900X202PXX42NPJR9THG58DNQPA72F2P7M2LUASE444A7/UUSK";
 export declare const YUM_KUJIRA_FACTORY_DENOM = "FACTORY/KUJIRA1YGFXN0ER40KLCNCK8THLTUPRDXLCK6WVNPKF2K/UYUM";
 export declare const DEFAULT_COSMOS_FEE_MAINNET: {
@@ -35,9 +34,154 @@ export declare function getDefaultChainFee(chain: CosmosChain): {
 export declare function getThorchainNativeFee(chain: TCLikeChain): Promise<SwapKitNumber>;
 export declare const getMsgSendDenom: (symbol: string, isThorchain?: boolean) => string;
 export declare const getDenomWithChain: ({ symbol, chain }: AssetValue) => string;
-export declare function createStargateClient(url: string): Promise<import("@cosmjs/stargate/build").StargateClient>;
-export declare function createSigningStargateClient(url: string, signer: OfflineSigner, optionsOrBaseGas?: string | SigningStargateClientOptions): Promise<import("@cosmjs/stargate/build").SigningStargateClient>;
-export declare function createOfflineStargateClient(wallet: OfflineSigner, registry?: SigningStargateClientOptions): Promise<import("@cosmjs/stargate/build").SigningStargateClient>;
+/** cosmjs `StdFee` shape — preserved here so callers don't change. */
+export type StdFee = {
+    amount: {
+        amount: string;
+        denom: string;
+    }[];
+    gas: string;
+    payer?: string;
+    granter?: string;
+};
+/** cosmjs `Coin` shape returned by `getAllBalances`. Renamed `BalanceCoin`
+ * to avoid clashing with `@swapkit/helpers` `Coin` (which uses `asset`). */
+export type BalanceCoin = {
+    amount: string;
+    denom: string;
+};
+/** cosmjs `Account` shape returned by `getAccount`. */
+export type StargateAccount = {
+    address: string;
+    pubkey: {
+        type: string;
+        value: Uint8Array;
+    } | null;
+    accountNumber: number;
+    sequence: number;
+};
+/** Alias kept for source compatibility with existing callers. */
+export type Account = StargateAccount;
+/** Output of `SigningStargateClient.sign` — same as cosmjs `TxRaw`. */
+export type SignedTx = {
+    bodyBytes: Uint8Array;
+    authInfoBytes: Uint8Array;
+    signatures: Uint8Array[];
+};
+/**
+ * Options accepted by `createSigningStargateClient`. Mirrors the cosmjs
+ * `SigningStargateClientOptions` subset that the toolbox actually uses:
+ * - `registry`     — encoder map merged with `defaultEncoders`
+ * - `aminoTypes`   — amino<->proto converter (lookup by typeUrl)
+ *
+ * Both shapes are intentionally `unknown`-typed at the boundary because the
+ * thorchain registry currently returns the legacy `Registry`/`AminoTypes`
+ * classes; the duck-typing we do is "if it has `.encodeAsAny` / `.fromAmino`,
+ * use it." This lets the existing thorchain registry implementation work
+ * unchanged while we incrementally migrate it (next file in this batch).
+ */
+export type SigningStargateClientOptions = {
+    registry?: ToolboxRegistry;
+    aminoTypes?: ToolboxAminoTypes;
+    /** Reserved — accepted for source compatibility, currently unused. */
+    gasPrice?: unknown;
+};
+/**
+ * Toolbox-facing registry duck type. Either a cosmos-signer-style encoder
+ * map, OR the legacy thorchain `Registry` instance with `.encode()`. The
+ * adapter detects via `"encode" in registry` and routes accordingly.
+ */
+export type ToolboxRegistry = EncoderMap | {
+    encode(value: {
+        typeUrl: string;
+        value: unknown;
+    }): Uint8Array;
+};
+/**
+ * Toolbox-facing amino types duck type. Either an object of
+ * `{ [typeUrl]: { aminoType, fromAmino, toAmino } }`, OR the legacy
+ * thorchain `AminoTypes` instance with `.fromAmino` / `.toAmino` methods.
+ *
+ * The converter shape uses very loose types so concrete implementations
+ * (THORChain registry) can register strongly-typed converters without
+ * fighting variance — the adapter only invokes them via duck typing.
+ */
+export type ToolboxAminoConverter = {
+    aminoType: string;
+    fromAmino: (v: any) => any;
+    toAmino: (v: any) => any;
+};
+export type ToolboxAminoTypes = {
+    readonly [typeUrl: string]: ToolboxAminoConverter;
+} | {
+    fromAmino(msg: {
+        type: string;
+        value: unknown;
+    }): {
+        typeUrl: string;
+        value: unknown;
+    };
+    toAmino(msg: {
+        typeUrl: string;
+        value: unknown;
+    }): {
+        type: string;
+        value: unknown;
+    };
+};
+export declare function createStargateClient(url: string): Promise<{
+    broadcastTx(txBytes: Uint8Array): Promise<{
+        transactionHash: string;
+        code: number;
+        rawLog: string;
+    }>;
+    getAccount(address: string): Promise<Account | null>;
+    getAllBalances(address: string): Promise<readonly BalanceCoin[]>;
+}>;
+export type StargateClientLike = Awaited<ReturnType<typeof createStargateClient>>;
+export declare function createSigningStargateClient(url: string, signer: OfflineSigner, optionsOrBaseGas?: string | SigningStargateClientOptions): Promise<{
+    broadcastTx(txBytes: Uint8Array): Promise<{
+        transactionHash: string;
+        code: number;
+        rawLog: string;
+    }>;
+    sendTokens(senderAddress: string, recipientAddress: string, amount: readonly {
+        amount: string;
+        denom: string;
+    }[], fee: StdFee, memo?: string): Promise<{
+        code: number;
+        rawLog: string;
+        transactionHash: string;
+    }>;
+    sign(signerAddress: string, msgs: {
+        typeUrl: string;
+        value: unknown;
+    }[], fee: StdFee, memo: string, signerData?: {
+        accountNumber: bigint;
+        chainId: string;
+        sequence: number | bigint;
+    }): Promise<SignedTx>;
+    signAndBroadcast(signerAddress: string, msgs: {
+        typeUrl: string;
+        value: unknown;
+    }[], fee: StdFee, memo?: string): Promise<{
+        code: number;
+        rawLog: string;
+        transactionHash: string;
+    }>;
+}>;
+export type SigningStargateClientLike = Awaited<ReturnType<typeof createSigningStargateClient>>;
+export declare function createOfflineStargateClient(wallet: OfflineSigner, options?: SigningStargateClientOptions): Promise<{
+    sign(signerAddress: string, msgs: {
+        typeUrl: string;
+        value: unknown;
+    }[], fee: StdFee, memo: string, signerData?: {
+        accountNumber: bigint;
+        chainId: string;
+        sequence: number | bigint;
+    }): Promise<SignedTx>;
+}>;
+export type OfflineStargateClientLike = Awaited<ReturnType<typeof createOfflineStargateClient>>;
 /**
  * Used to build tx for Cosmos and Kujira
  */

package/dist/types/hypercore/__tests__/fixtures.d.ts

@@ -0,0 +1,40 @@
+export declare const usdcTokenId = "USDC:0x6d1e7cde53ba9467b783cb7c530ce054";
+export declare const payinMessage: {
+    amount: string;
+    destination: string;
+    destinationDex: string;
+    fromSubAccount: string;
+    hyperliquidChain: "Mainnet";
+    nonce: number;
+    sourceDex: string;
+    token: string;
+};
+export declare const payinAction: {
+    signatureChainId: string;
+    type: "sendAsset";
+    amount: string;
+    destination: string;
+    destinationDex: string;
+    fromSubAccount: string;
+    hyperliquidChain: "Mainnet";
+    nonce: number;
+    sourceDex: string;
+    token: string;
+};
+export declare const payinDomain: {
+    chainId: number;
+    name: string;
+    verifyingContract: string;
+    version: string;
+};
+export declare const sendAssetStruct: {
+    name: string;
+    type: string;
+}[];
+export declare const sendAssetStructTypes: {
+    "HyperliquidTransaction:SendAsset": {
+        name: string;
+        type: string;
+    }[];
+};
+export declare const payinDigest = "0x466d43f280b7fda240a3a97a424aaef3f2645e284425362d5c686094761b1b9e";