@uswap/toolboxes 4.3.6

package/src/cosmos/thorchainUtils/types/client-types.ts

@@ -0,0 +1,54 @@
+import type { EncodeObject } from "@cosmjs/proto-signing";
+import type { Asset, ChainId, GenericTransferParams } from "@uswap/helpers";
+import type { CosmosCreateTransactionParams } from "../../types";
+
+enum TxType {
+  Transfer = "transfer",
+  Unknown = "unknown",
+}
+
+type Tx = {
+  asset: Asset; // asset
+  from: { from: string }[]; // list of "from" txs. BNC will have one `TxFrom` only, `BTC` might have many transactions going "in" (based on UTXO)
+  to: { to: string }[]; // list of "to" transactions. BNC will have one `TxTo` only, `BTC` might have many transactions going "out" (based on UTXO)
+  date: Date; // timestamp of tx
+  type: TxType; // type
+  hash: string; // Tx hash
+};
+
+export type NodeUrl = { node: string; rpc: string };
+
+export type TxData = Pick<Tx, "from" | "to" | "type">;
+
+/**
+ * Response from `thorchain/constants` endpoint
+ */
+export type ThorchainConstantsResponse = {
+  int_64_values: {
+    // We are in fee interested only - ignore all other values
+    NativeTransactionFee: number;
+  };
+};
+
+/**
+ * Response of `/cosmos/base/tendermint/v1beta1/node_info`
+ * Note: We are interested in `network` (aka chain id) only
+ */
+export type NodeInfoResponse = { default_node_info: { network: string } };
+
+export type TransferTransaction = {
+  memo: string;
+  accountNumber: number;
+  sequence: number;
+  chainId: ChainId;
+  msgs: EncodeObject[];
+  fee: { amount: { denom: string; amount: string }[]; gas: string };
+};
+
+export type ThorchainCreateTransactionParams = Omit<CosmosCreateTransactionParams, "feeRate" | "recipient"> & {
+  recipient?: string;
+  asSignable?: boolean;
+  asAminoMessage?: boolean;
+};
+
+export type ThorchainDepositParams = Omit<GenericTransferParams, "recipient">;

package/src/cosmos/thorchainUtils/types/index.ts

@@ -0,0 +1 @@
+export * from "./client-types";

package/src/cosmos/toolbox/cosmos.ts

@@ -0,0 +1,345 @@
+import type { StdFee } from "@cosmjs/amino";
+import type { Account } from "@cosmjs/stargate";
+import { base64, bech32 } from "@scure/base";
+import {
+  AssetValue,
+  applyFeeMultiplier,
+  Chain,
+  type ChainId,
+  type CosmosChain,
+  CosmosChainPrefixes,
+  DerivationPath,
+  type DerivationPathArray,
+  derivationPathToString,
+  FeeOption,
+  type GenericTransferParams,
+  getChainConfig,
+  getRPCUrl,
+  NetworkDerivationPath,
+  SwapKitError,
+  SwapKitNumber,
+  type TCLikeChain,
+  updateDerivationPath,
+} from "@uswap/helpers";
+import { SwapKitApi } from "@uswap/helpers/api";
+import { match, P } from "ts-pattern";
+import type { CosmosToolboxParams } from "../types";
+import {
+  cosmosCreateTransaction,
+  createSigningStargateClient,
+  createStargateClient,
+  getAssetFromDenom,
+  getDenomWithChain,
+  getMsgSendDenom,
+} from "../util";
+
+export async function fetchFeeRateFromSwapKit(chainId: ChainId, safeDefault: number) {
+  try {
+    const response = await SwapKitApi.getGasRate();
+    const responseGasRate = response.find((gas) => gas.chainId === chainId)?.value;
+
+    return responseGasRate ? Number.parseFloat(responseGasRate) : safeDefault;
+  } catch {
+    return safeDefault;
+  }
+}
+
+export async function getSignerFromPhrase({
+  phrase,
+  prefix,
+  ...derivationParams
+}: { phrase: string; prefix?: string } & ({ chain: Chain; index?: number } | { derivationPath: string })) {
+  const importedProtoSigning = await import("@cosmjs/proto-signing");
+  const DirectSecp256k1HdWallet =
+    importedProtoSigning.DirectSecp256k1HdWallet ?? importedProtoSigning.default?.DirectSecp256k1HdWallet;
+  const importedCrypto = await import("@cosmjs/crypto");
+  const stringToPath = importedCrypto.stringToPath ?? importedCrypto.default?.stringToPath;
+
+  const derivationPath =
+    "derivationPath" in derivationParams
+      ? derivationParams.derivationPath
+      : `${DerivationPath[derivationParams.chain]}/${derivationParams.index}`;
+
+  return DirectSecp256k1HdWallet.fromMnemonic(phrase, { hdPaths: [stringToPath(derivationPath)], prefix });
+}
+
+export async function getSignerFromPrivateKey({ privateKey, prefix }: { privateKey: Uint8Array; prefix: string }) {
+  const importedProtoSigning = await import("@cosmjs/proto-signing");
+  const DirectSecp256k1Wallet =
+    importedProtoSigning.DirectSecp256k1Wallet ?? importedProtoSigning.default?.DirectSecp256k1Wallet;
+
+  return DirectSecp256k1Wallet.fromKey(privateKey, prefix);
+}
+
+const SafeDefaultFeeValues = {
+  [Chain.Cosmos]: 1000,
+  [Chain.Kujira]: 1000,
+  [Chain.Noble]: 1000,
+  [Chain.THORChain]: 5000000,
+  [Chain.Maya]: 5000000,
+  [Chain.Harbor]: 5000000,
+};
+
+export function verifySignature(getAccount: (address: string) => Promise<Account | null>) {
+  return async function verifySignature({
+    signature,
+    message,
+    address,
+  }: {
+    signature: string;
+    message: string;
+    address: string;
+  }) {
+    const account = await getAccount(address);
+    if (!account?.pubkey) throw new SwapKitError("toolbox_cosmos_verify_signature_no_pubkey");
+
+    const importedCrypto = await import("@cosmjs/crypto");
+    const Secp256k1Signature = importedCrypto.Secp256k1Signature ?? importedCrypto.default?.Secp256k1Signature;
+    const Secp256k1 = importedCrypto.Secp256k1 ?? importedCrypto.default?.Secp256k1;
+
+    const secpSignature = Secp256k1Signature.fromFixedLength(base64.decode(signature));
+    return Secp256k1.verifySignature(secpSignature, base64.decode(message), account.pubkey.value);
+  };
+}
+
+export async function createCosmosToolbox({ chain, ...toolboxParams }: CosmosToolboxParams) {
+  const rpcUrl = await getRPCUrl(chain);
+  const chainPrefix = CosmosChainPrefixes[chain];
+
+  const index = "index" in toolboxParams ? toolboxParams.index || 0 : 0;
+  const derivationPath = derivationPathToString(
+    "derivationPath" in toolboxParams && toolboxParams.derivationPath
+      ? toolboxParams.derivationPath
+      : updateDerivationPath(NetworkDerivationPath[chain], { index }),
+  );
+
+  const signer = await match(toolboxParams)
+    .with({ phrase: P.string }, ({ phrase }) => getSignerFromPhrase({ derivationPath, phrase, prefix: chainPrefix }))
+    .with({ signer: P.any }, ({ signer }) => signer)
+    .otherwise(() => undefined);
+
+  async function getAccount(address: string) {
+    const client = await createStargateClient(rpcUrl);
+    return client.getAccount(address);
+  }
+
+  async function getAddress() {
+    const [account] = (await signer?.getAccounts()) || [];
+    return account?.address;
+  }
+
+  async function getPubKey() {
+    const [account] = (await signer?.getAccounts()) || [];
+    if (!account?.pubkey) {
+      throw new SwapKitError("toolbox_cosmos_signer_not_defined");
+    }
+    return base64.encode(account?.pubkey);
+  }
+
+  async function signTransaction({
+    recipient,
+    assetValue,
+    memo = "",
+    feeRate,
+    feeOptionKey = FeeOption.Fast,
+  }: GenericTransferParams) {
+    const from = await getAddress();
+
+    if (!(signer && from)) {
+      throw new SwapKitError("toolbox_cosmos_signer_not_defined");
+    }
+
+    const feeAssetValue = AssetValue.from({ chain });
+    const assetDenom = getDenomWithChain(feeAssetValue);
+    const txFee = feeRate || feeToStdFee((await getFees(chain, SafeDefaultFeeValues[chain]))[feeOptionKey], assetDenom);
+
+    const signingClient = await createSigningStargateClient(rpcUrl, signer);
+    const denom = getMsgSendDenom(assetValue.symbol);
+    const amount = assetValue.getBaseValue("string");
+
+    const { TxRaw } = await import("cosmjs-types/cosmos/tx/v1beta1/tx");
+
+    const msgSend = { amount: [{ amount, denom }], fromAddress: from, toAddress: recipient };
+
+    const txRaw = await signingClient.sign(
+      from,
+      [{ typeUrl: "/cosmos.bank.v1beta1.MsgSend", value: msgSend }],
+      txFee as StdFee,
+      memo,
+    );
+
+    const txBytes = TxRaw.encode(txRaw).finish();
+    return Buffer.from(txBytes).toString("hex");
+  }
+
+  async function transfer({
+    recipient,
+    assetValue,
+    memo = "",
+    feeRate,
+    feeOptionKey = FeeOption.Fast,
+    dryRun = false,
+  }: GenericTransferParams & { dryRun?: boolean }) {
+    if (dryRun) {
+      return signTransaction({ assetValue, feeOptionKey, feeRate, memo, recipient });
+    }
+
+    const from = await getAddress();
+
+    if (!(signer && from)) {
+      throw new SwapKitError("toolbox_cosmos_signer_not_defined");
+    }
+
+    const feeAssetValue = AssetValue.from({ chain });
+    const assetDenom = getDenomWithChain(feeAssetValue);
+    const txFee = feeRate || feeToStdFee((await getFees(chain, SafeDefaultFeeValues[chain]))[feeOptionKey], assetDenom);
+
+    const signingClient = await createSigningStargateClient(rpcUrl, signer);
+    const denom = getMsgSendDenom(assetValue.symbol);
+    const message = [{ amount: assetValue.getBaseValue("string"), denom }];
+
+    const { transactionHash } = await signingClient.sendTokens(from, recipient, message, txFee, memo);
+
+    return transactionHash;
+  }
+
+  return {
+    createPrivateKeyFromPhrase: createPrivateKeyFromPhrase(derivationPath),
+    createTransaction: cosmosCreateTransaction,
+    fetchFeeRateFromSwapKit,
+    getAccount,
+    getAddress,
+    getBalance: async (address: string, _potentialScamFilter?: boolean) => {
+      const denomBalances = await cosmosBalanceDenomsGetter(rpcUrl)(address);
+      const balances = await Promise.all(
+        denomBalances
+          .filter(({ denom }) => denom && !denom.includes("IBC/"))
+          .map(({ denom, amount }) => {
+            const fullDenom =
+              [Chain.THORChain, Chain.Maya].includes(chain as TCLikeChain) &&
+              (denom.includes("/") || denom.includes("˜"))
+                ? `${chain}.${denom}`
+                : denom;
+            return getAssetFromDenom(fullDenom, amount);
+          }),
+      );
+
+      if (balances.length === 0) {
+        return [AssetValue.from({ chain })];
+      }
+
+      return balances;
+    },
+    getBalanceAsDenoms: cosmosBalanceDenomsGetter(rpcUrl),
+    getFees: () => getFees(chain, SafeDefaultFeeValues[chain]),
+    getPubKey,
+    getSignerFromPhrase: async ({ phrase, derivationPath }: { phrase: string; derivationPath: DerivationPathArray }) =>
+      getSignerFromPhrase({
+        derivationPath: derivationPathToString(derivationPath),
+        index,
+        phrase,
+        prefix: chainPrefix,
+      }),
+    getSignerFromPrivateKey: async (privateKey: Uint8Array) => {
+      const importedSigning = await import("@cosmjs/proto-signing");
+      const DirectSecp256k1Wallet =
+        importedSigning.DirectSecp256k1Wallet ?? importedSigning.default?.DirectSecp256k1Wallet;
+      return DirectSecp256k1Wallet.fromKey(privateKey, chainPrefix);
+    },
+    signTransaction,
+    transfer,
+    validateAddress: getCosmosValidateAddress(chain),
+    verifySignature: verifySignature(getAccount),
+  };
+}
+
+export async function getFeeRateFromSwapKit(chainId: ChainId, safeDefault: number) {
+  try {
+    const response = await SwapKitApi.getGasRate();
+    const responseGasRate = response.find((gas) => gas.chainId === chainId)?.value;
+
+    return responseGasRate ? Number.parseFloat(responseGasRate) : safeDefault;
+  } catch {
+    return safeDefault;
+  }
+}
+
+export function estimateTransactionFee({ assetValue: { chain } }: { assetValue: AssetValue }) {
+  return AssetValue.from({ chain, value: getMinTransactionFee(chain) });
+}
+
+async function getFees(chain: Chain, safeDefault: number) {
+  const { chainId, baseDecimal } = getChainConfig(chain);
+
+  const baseFee = await fetchFeeRateFromSwapKit(chainId, safeDefault);
+  return {
+    average: SwapKitNumber.fromBigInt(BigInt(baseFee), baseDecimal),
+    fast: SwapKitNumber.fromBigInt(BigInt(applyFeeMultiplier(baseFee, FeeOption.Fast, true)), baseDecimal),
+    fastest: SwapKitNumber.fromBigInt(BigInt(applyFeeMultiplier(baseFee, FeeOption.Fastest, true)), baseDecimal),
+  } as { [key in FeeOption]: SwapKitNumber };
+}
+
+function feeToStdFee(fee: SwapKitNumber, denom: string): StdFee {
+  return { amount: [{ amount: fee.getBaseValue("string"), denom }], gas: "200000" };
+}
+
+function getMinTransactionFee(chain: Chain) {
+  return (
+    {
+      [Chain.Cosmos]: 0.007,
+      [Chain.Kujira]: 0.02,
+      [Chain.Noble]: 0.01,
+      [Chain.THORChain]: 0.02,
+      [Chain.Maya]: 0.02,
+      [Chain.Harbor]: 0.02,
+    }[chain as CosmosChain] || 0
+  );
+}
+
+export function getCosmosValidateAddress(chain: CosmosChain) {
+  const chainPrefix = CosmosChainPrefixes[chain];
+  return function validateAddress(address: string) {
+    if (!address.startsWith(chainPrefix)) return false;
+
+    try {
+      const { prefix, words } = bech32.decode(address as `${string}1${string}`);
+      const normalized = bech32.encode(prefix, words);
+
+      return normalized === address.toLocaleLowerCase();
+    } catch {
+      return false;
+    }
+  };
+}
+
+function cosmosBalanceDenomsGetter(rpcUrl: string) {
+  return async function getCosmosBalanceDenoms(address: string) {
+    const client = await createStargateClient(rpcUrl);
+    const allBalances = await client.getAllBalances(address);
+
+    const balances = allBalances.map((balance) => ({
+      ...balance,
+      denom: balance.denom.includes("/") ? balance.denom.toUpperCase() : balance.denom,
+    }));
+
+    return balances;
+  };
+}
+
+function createPrivateKeyFromPhrase(derivationPath: string) {
+  return async function createPrivateKeyFromPhrase(phrase: string) {
+    const importedCrypto = await import("@cosmjs/crypto");
+    const stringToPath = importedCrypto.stringToPath ?? importedCrypto.default?.stringToPath;
+    const Slip10Curve = importedCrypto.Slip10Curve ?? importedCrypto.default?.Slip10Curve;
+    const Slip10 = importedCrypto.Slip10 ?? importedCrypto.default?.Slip10;
+    const EnglishMnemonic = importedCrypto.EnglishMnemonic ?? importedCrypto.default?.EnglishMnemonic;
+    const Bip39 = importedCrypto.Bip39 ?? importedCrypto.default?.Bip39;
+
+    const mnemonicChecked = new EnglishMnemonic(phrase);
+    const seed = await Bip39.mnemonicToSeed(mnemonicChecked);
+
+    const { privkey } = Slip10.derivePath(Slip10Curve.Secp256k1, seed, stringToPath(derivationPath));
+
+    return privkey;
+  };
+}

package/src/cosmos/toolbox/index.ts

@@ -0,0 +1,35 @@
+import { Chain, type CosmosChain, SwapKitError } from "@uswap/helpers";
+
+import type { CosmosToolboxParams } from "../types";
+import { createCosmosToolbox } from "./cosmos";
+import { createThorchainToolbox } from "./thorchain";
+
+export type CosmosToolboxes = {
+  GAIA: ReturnType<typeof createCosmosToolbox>;
+  KUJI: ReturnType<typeof createCosmosToolbox>;
+  MAYA: ReturnType<typeof createThorchainToolbox>;
+  NOBLE: ReturnType<typeof createCosmosToolbox>;
+  THOR: ReturnType<typeof createThorchainToolbox>;
+};
+
+export const getCosmosToolbox = <T extends Exclude<CosmosChain, Chain.Harbor>>(
+  chain: T,
+  params?: Omit<CosmosToolboxParams, "chain">,
+): CosmosToolboxes[T] => {
+  switch (chain) {
+    case Chain.Cosmos:
+    case Chain.Kujira:
+    case Chain.Noble:
+      return createCosmosToolbox({ chain, ...params }) as CosmosToolboxes[T];
+
+    case Chain.Maya:
+    case Chain.THORChain:
+      return createThorchainToolbox({ chain, ...params }) as CosmosToolboxes[T];
+
+    default:
+      throw new SwapKitError("toolbox_cosmos_not_supported", { chain });
+  }
+};
+
+export * from "./cosmos";
+export * from "./thorchain";

package/src/cosmos/toolbox/thorchain.ts

@@ -0,0 +1,249 @@
+import type { Pubkey, Secp256k1HdWallet } from "@cosmjs/amino";
+import { base64 } from "@scure/base";
+import {
+  Chain,
+  CosmosChainPrefixes,
+  derivationPathToString,
+  FeeOption,
+  type GenericTransferParams,
+  getChainConfig,
+  getRPCUrl,
+  NetworkDerivationPath,
+  RequestClient,
+  SKConfig,
+  SwapKitError,
+  SwapKitNumber,
+  type TCLikeChain,
+  updateDerivationPath,
+} from "@uswap/helpers";
+
+import { match, P } from "ts-pattern";
+import {
+  buildAminoMsg,
+  buildEncodedTxBody,
+  convertToSignable,
+  createDefaultAminoTypes,
+  createDefaultRegistry,
+  getCreateTransaction,
+  parseAminoMessageForDirectSigning,
+} from "../thorchainUtils";
+import type { ThorchainConstantsResponse } from "../thorchainUtils/types/client-types";
+import type { CosmosToolboxParams, MultiSigSigner, MultisigTx } from "../types";
+import {
+  createOfflineStargateClient,
+  createSigningStargateClient,
+  createStargateClient,
+  getDefaultChainFee,
+} from "../util";
+import { createCosmosToolbox } from "./cosmos";
+
+function secp256k1HdWalletFromMnemonic({ prefix, derivationPath }: { prefix: string; derivationPath?: string }) {
+  return async function secp256k1HdWalletFromMnemonic(mnemonic: string, index = 0) {
+    const importedAmino = await import("@cosmjs/amino");
+    const Secp256k1HdWallet = importedAmino.Secp256k1HdWallet ?? importedAmino.default?.Secp256k1HdWallet;
+    const importedCrypto = await import("@cosmjs/crypto");
+    const stringToPath = importedCrypto.stringToPath ?? importedCrypto.default?.stringToPath;
+
+    return Secp256k1HdWallet.fromMnemonic(mnemonic, { hdPaths: [stringToPath(`${derivationPath}/${index}`)], prefix });
+  };
+}
+
+function exportSignature(signature: Uint8Array) {
+  return base64.encode(signature);
+}
+
+function signMultisigTx(chain: TCLikeChain) {
+  return async function signMultisigTx({ wallet, tx }: { wallet: Secp256k1HdWallet; tx: string | MultisigTx }) {
+    const { msgs, accountNumber, sequence, chainId, fee, memo } = typeof tx === "string" ? JSON.parse(tx) : tx;
+
+    const address = (await wallet.getAccounts())?.[0]?.address || "";
+    const aminoTypes = await createDefaultAminoTypes(chain);
+    const registry = await createDefaultRegistry();
+    const signingClient = await createOfflineStargateClient(wallet, { aminoTypes, registry });
+    const msgForSigning = [];
+
+    for (const msg of msgs) {
+      const signMsg = await convertToSignable(msg, chain);
+      msgForSigning.push(signMsg);
+    }
+
+    const {
+      signatures: [signature],
+    } = await signingClient.sign(address, msgForSigning, fee, memo, { accountNumber, chainId, sequence });
+
+    const bodyBytes = await buildEncodedTxBody({ chain, memo, msgs: msgs.map(parseAminoMessageForDirectSigning) });
+
+    return { bodyBytes, signature: exportSignature(signature as Uint8Array) };
+  };
+}
+
+function broadcastMultisigTx({ prefix, rpcUrl }: { prefix: string; rpcUrl: string }) {
+  return async function broadcastMultisigTx(
+    tx: string,
+    signers: MultiSigSigner[],
+    membersPubKeys: string[],
+    threshold: number,
+    bodyBytes: Uint8Array,
+  ) {
+    const { encodeSecp256k1Pubkey, pubkeyToAddress } = (await import("@cosmjs/amino")).default;
+    const { makeMultisignedTxBytes } = (await import("@cosmjs/stargate")).default;
+
+    const { sequence, fee } = JSON.parse(tx);
+    const multisigPubkey = await createMultisig(membersPubKeys, threshold);
+
+    const addressesAndSignatures: [string, Uint8Array][] = signers.map((signer) => [
+      pubkeyToAddress(encodeSecp256k1Pubkey(base64.decode(signer.pubKey)), prefix),
+      base64.decode(signer.signature),
+    ]);
+
+    const broadcaster = await createStargateClient(rpcUrl);
+
+    const { transactionHash } = await broadcaster.broadcastTx(
+      makeMultisignedTxBytes(
+        multisigPubkey,
+        sequence,
+        fee,
+        bodyBytes,
+        new Map<string, Uint8Array>(addressesAndSignatures),
+      ),
+    );
+
+    return transactionHash;
+  };
+}
+
+async function createMultisig(pubKeys: string[], threshold: number, noSortPubKeys = true) {
+  const { createMultisigThresholdPubkey, encodeSecp256k1Pubkey } = (await import("@cosmjs/amino")).default;
+  return createMultisigThresholdPubkey(
+    pubKeys.map((pubKey) => encodeSecp256k1Pubkey(base64.decode(pubKey))),
+    threshold,
+    noSortPubKeys,
+  );
+}
+
+function importSignature(signature: string) {
+  return base64.decode(signature);
+}
+
+async function signWithPrivateKey({ privateKey, message }: { privateKey: Uint8Array; message: string }) {
+  const { Secp256k1 } = (await import("@cosmjs/crypto")).default;
+
+  const signature = await Secp256k1.createSignature(base64.decode(message), privateKey);
+  return base64.encode(Buffer.concat([signature.r(32), signature.s(32)]));
+}
+
+export async function createThorchainToolbox({ chain, ...toolboxParams }: CosmosToolboxParams<TCLikeChain>) {
+  const rpcUrl = await getRPCUrl(chain);
+  const { nodeUrl } = getChainConfig(chain);
+  const { isStagenet } = SKConfig.get("envs");
+  const isThorchain = chain === Chain.THORChain;
+  const chainPrefix = `${isStagenet ? "s" : ""}${CosmosChainPrefixes[chain]}`;
+
+  const index = "index" in toolboxParams ? toolboxParams.index || 0 : 0;
+
+  const derivationPath =
+    "derivationPath" in toolboxParams && toolboxParams.derivationPath
+      ? toolboxParams.derivationPath
+      : updateDerivationPath(NetworkDerivationPath[chain], { index });
+
+  const cosmosToolbox = await createCosmosToolbox({ chain, ...toolboxParams });
+
+  const signer = await match(toolboxParams)
+    .with({ phrase: P.string }, ({ phrase }) => cosmosToolbox.getSignerFromPhrase({ derivationPath, phrase }))
+    .with({ signer: P.any }, ({ signer }) => signer)
+    .otherwise(() => undefined);
+
+  const defaultFee = getDefaultChainFee(chain);
+
+  async function getFees() {
+    let fee: SwapKitNumber;
+
+    const constantsUrl = `${nodeUrl}/${isThorchain ? "thorchain" : "mayachain"}/constants`;
+
+    try {
+      const {
+        int_64_values: { NativeTransactionFee: nativeFee },
+      } = await RequestClient.get<ThorchainConstantsResponse>(constantsUrl);
+
+      if (!nativeFee || Number.isNaN(nativeFee) || nativeFee < 0) {
+        throw new SwapKitError("toolbox_cosmos_invalid_fee", { nativeFee: nativeFee.toString() });
+      }
+
+      fee = new SwapKitNumber(nativeFee);
+    } catch {
+      fee = new SwapKitNumber({ decimal: getChainConfig(chain).baseDecimal, value: isThorchain ? 0.02 : 1 });
+    }
+
+    return { [FeeOption.Average]: fee, [FeeOption.Fast]: fee, [FeeOption.Fastest]: fee };
+  }
+
+  async function transfer({
+    assetValue,
+    memo = "",
+    recipient,
+  }: Omit<GenericTransferParams, "recipient"> & { recipient?: string }) {
+    const { TxRaw } = await import("cosmjs-types/cosmos/tx/v1beta1/tx");
+    const sender = (await signer?.getAccounts())?.[0]?.address;
+    if (!(sender && signer)) throw new SwapKitError("toolbox_cosmos_no_signer");
+
+    const isAminoSigner = "signAmino" in signer;
+    const registry = await createDefaultRegistry();
+    const aminoTypes = await createDefaultAminoTypes(chain);
+    const signingClient = await createSigningStargateClient(rpcUrl, signer, { aminoTypes, registry });
+
+    const aminoMessage = buildAminoMsg({ assetValue, memo, recipient, sender });
+
+    if (isAminoSigner) {
+      const msgSign = await convertToSignable(aminoMessage, chain);
+
+      const { signatures, authInfoBytes } = await signingClient.sign(sender, [msgSign], defaultFee, memo);
+
+      const tx = TxRaw.encode({
+        authInfoBytes,
+        bodyBytes: await buildEncodedTxBody({
+          chain,
+          memo,
+          msgs: [aminoMessage].map(parseAminoMessageForDirectSigning),
+        }),
+        signatures,
+      }).finish();
+
+      const txResponse = await signingClient.broadcastTx(tx);
+
+      return txResponse.transactionHash;
+    }
+
+    const preparedMessage = parseAminoMessageForDirectSigning(aminoMessage);
+    const msgSign = await convertToSignable(preparedMessage, chain);
+    const txResponse = await signingClient.signAndBroadcast(sender, [msgSign], defaultFee, memo);
+
+    return txResponse.transactionHash;
+  }
+
+  return {
+    ...cosmosToolbox,
+    broadcastMultisigTx: broadcastMultisigTx({ prefix: chainPrefix, rpcUrl }),
+    buildAminoMsg,
+    buildEncodedTxBody,
+    convertToSignable,
+    createDefaultAminoTypes: () => createDefaultAminoTypes(chain),
+    createDefaultRegistry,
+    createMultisig,
+    createTransaction: getCreateTransaction(rpcUrl),
+    deposit: transfer,
+    getFees,
+    importSignature,
+    parseAminoMessageForDirectSigning,
+    pubkeyToAddress: async (pubkey: Pubkey) => {
+      const { pubkeyToAddress } = (await import("@cosmjs/amino")).default;
+      return pubkeyToAddress(pubkey, chainPrefix);
+    },
+    secp256k1HdWalletFromMnemonic: secp256k1HdWalletFromMnemonic({
+      derivationPath: derivationPathToString(derivationPath),
+      prefix: chainPrefix,
+    }),
+    signMultisigTx: signMultisigTx(chain),
+    signWithPrivateKey,
+    transfer,
+  };
+}