@swapkit/toolboxes 1.0.0-beta.3 → 1.0.0-beta.31

package/package.json

@@ -11,16 +11,19 @@
     "@cosmjs/proto-signing": "0.33.1",
     "@cosmjs/stargate": "0.33.1",
     "@polkadot/api": "15.9.2",
-    "@polkadot/keyring": "13.4.4",
-    "@polkadot/util": "13.4.4",
-    "@polkadot/util-crypto": "13.4.4",
+    "@polkadot/keyring": "13.5.1",
+    "@polkadot/util": "13.5.1",
+    "@polkadot/util-crypto": "13.5.1",
     "@psf/bitcoincashjs-lib": "4.0.3",
     "@radixdlt/babylon-gateway-api-sdk": "1.10.1",
     "@radixdlt/radix-dapp-toolkit": "2.2.1",
-    "@scure/base": "1.2.4",
-    "@scure/bip32": "1.6.2",
-    "@scure/bip39": "1.5.4",
-    "@swapkit/helpers": "3.0.0-beta.3",
+    "@scure/base": "1.2.6",
+    "@scure/bip32": "1.7.0",
+    "@scure/bip39": "1.6.0",
+    "@solana/spl-memo": "0.2.5",
+    "@solana/spl-token": "0.4.13",
+    "@solana/web3.js": "1.98.2",
+    "@swapkit/helpers": "3.0.0-beta.21",
     "base64-js": "1.5.1",
     "bitcoinjs-lib": "6.1.7",
     "bs58check": "4.0.0",
@@ -28,65 +31,74 @@
     "coininfo": "5.2.1",
     "cosmjs-types": "0.9.0",
     "ecpair": "2.1.0",
-    "ethers": "6.13.5",
-    "micro-key-producer": "0.7.5",
-    "protobufjs": "7.4.0",
-    "ts-pattern": "5.7.0",
-    "xrpl": "4.2.0"
-  },
-  "peerDependencies": {
-    "@solana/spl-memo": "0.2.5",
-    "@solana/spl-token": "0.4.13",
-    "@solana/web3.js": "1.98.0"
+    "ethers": "6.14.3",
+    "micro-key-producer": "0.7.6",
+    "near-api-js": "^6.1.0",
+    "near-sdk-js": "^2.0.0",
+    "near-seed-phrase": "^0.2.0",
+    "protobufjs": "7.5.3",
+    "tronweb": "6.0.3",
+    "ts-pattern": "5.7.1",
+    "xrpl": "4.3.0"
   },
   "devDependencies": {
-    "@nomicfoundation/hardhat-ethers": "3.0.8",
+    "@nomicfoundation/hardhat-ethers": "3.0.9",
     "@nomicfoundation/hardhat-toolbox": "5.0.0",
     "@polkadot/types": "15.9.2",
-    "@types/bn.js": "5.1.6",
+    "@types/bn.js": "5.2.0",
     "@types/crypto-js": "4.2.2",
     "@types/elliptic": "6.4.18",
-    "hardhat": "2.23.0"
+    "hardhat": "2.24.2"
   },
   "exports": {
     ".": {
-      "default": "./dist/index.js",
-      "require": "./dist/index.cjs",
+      "default": "./dist/src/index.js",
+      "require": "./dist/src/index.cjs",
       "types": "./src/index.ts"
     },
     "./cosmos": {
-      "default": "./dist/cosmos/index.js",
-      "require": "./dist/cosmos/index.cjs",
+      "default": "./dist/src/cosmos/index.js",
+      "require": "./dist/src/cosmos/index.cjs",
       "types": "./src/cosmos/index.ts"
     },
     "./evm": {
-      "default": "./dist/evm/index.js",
-      "require": "./dist/evm/index.cjs",
+      "default": "./dist/src/evm/index.js",
+      "require": "./dist/src/evm/index.cjs",
       "types": "./src/evm/index.ts"
     },
+    "./near": {
+      "default": "./dist/src/near/index.js",
+      "require": "./dist/src/near/index.cjs",
+      "types": "./src/near/index.ts"
+    },
     "./radix": {
-      "default": "./dist/radix/index.js",
-      "require": "./dist/radix/index.cjs",
+      "default": "./dist/src/radix/index.js",
+      "require": "./dist/src/radix/index.cjs",
       "types": "./src/radix/index.ts"
     },
     "./ripple": {
-      "default": "./dist/ripple/index.js",
-      "require": "./dist/ripple/index.cjs",
+      "default": "./dist/src/ripple/index.js",
+      "require": "./dist/src/ripple/index.cjs",
       "types": "./src/ripple/index.ts"
     },
     "./solana": {
-      "default": "./dist/solana/index.js",
-      "require": "./dist/solana/index.cjs",
+      "default": "./dist/src/solana/index.js",
+      "require": "./dist/src/solana/index.cjs",
       "types": "./src/solana/index.ts"
     },
     "./substrate": {
-      "default": "./dist/substrate/index.js",
-      "require": "./dist/substrate/index.cjs",
+      "default": "./dist/src/substrate/index.js",
+      "require": "./dist/src/substrate/index.cjs",
       "types": "./src/substrate/index.ts"
     },
+    "./tron": {
+      "default": "./dist/src/tron/index.js",
+      "require": "./dist/src/tron/index.cjs",
+      "types": "./src/tron/index.ts"
+    },
     "./utxo": {
-      "default": "./dist/utxo/index.js",
-      "require": "./dist/utxo/index.cjs",
+      "default": "./dist/src/utxo/index.js",
+      "require": "./dist/src/utxo/index.cjs",
       "types": "./src/utxo/index.ts"
     }
   },
@@ -107,5 +119,5 @@
     "type-check:go": "tsgo"
   },
   "type": "module",
-  "version": "1.0.0-beta.3"
+  "version": "1.0.0-beta.31"
 }

package/src/cosmos/thorchainUtils/addressFormat.ts

@@ -1,4 +1,5 @@
 import { base64, bech32 } from "@scure/base";
+import { SwapKitError } from "@swapkit/helpers";
 import { fromByteArray, toByteArray } from "base64-js";
 
 export function bech32ToBase64(address: string) {
@@ -17,7 +18,9 @@ export function toBase64(data: Uint8Array) {
 
 export function fromBase64(base64String: string) {
   if (!base64String.match(/^[a-zA-Z0-9+/]*={0,2}$/)) {
-    throw new Error("Invalid base64 string format");
+    throw new SwapKitError("toolbox_cosmos_invalid_params", {
+      error: "Invalid base64 string format",
+    });
   }
   return toByteArray(base64String);
 }

package/src/cosmos/thorchainUtils/messages.ts

@@ -1,5 +1,5 @@
 import type { TxBodyEncodeObject } from "@cosmjs/proto-signing";
-import { AssetValue, Chain, ChainToChainId } from "@swapkit/helpers";
+import { AssetValue, Chain, ChainToChainId, SwapKitError } from "@swapkit/helpers";
 
 import {
   createStargateClient,
@@ -104,7 +104,7 @@ const getAccount = async ({ rpcUrl, sender }: { sender: string; rpcUrl: string }
   const account = await client.getAccount(sender);
 
   if (!account) {
-    throw new Error("Account does not exist");
+    throw new SwapKitError("toolbox_cosmos_account_not_found", { sender });
   }
 
   return account;

package/src/cosmos/thorchainUtils/registry.ts

@@ -3,8 +3,8 @@ import { base64ToBech32, bech32ToBase64 } from "./addressFormat";
 
 export async function createDefaultRegistry() {
   const { $root } = await import("./types/MsgCompiled");
-  const { Registry } = await import("@cosmjs/proto-signing");
-  const { defaultRegistryTypes } = await import("@cosmjs/stargate");
+  const { Registry } = (await import("@cosmjs/proto-signing")).default;
+  const { defaultRegistryTypes } = (await import("@cosmjs/stargate")).default;
 
   return new Registry([
     ...defaultRegistryTypes,
@@ -14,7 +14,7 @@ export async function createDefaultRegistry() {
 }
 
 export async function createDefaultAminoTypes(chain: Chain.THORChain | Chain.Maya) {
-  const { AminoTypes } = await import("@cosmjs/stargate");
+  const { AminoTypes } = (await import("@cosmjs/stargate")).default;
   const aminoTypePrefix = chain === Chain.THORChain ? "thorchain" : "mayachain";
 
   return new AminoTypes({

package/src/cosmos/toolbox/cosmos.ts

@@ -17,17 +17,18 @@ import {
   SKConfig,
   SwapKitError,
   SwapKitNumber,
+  applyFeeMultiplier,
   derivationPathToString,
   updateDerivationPath,
 } from "@swapkit/helpers";
 import { SwapKitApi } from "@swapkit/helpers/api";
 import { P, match } from "ts-pattern";
-import { getBalance } from "../../utils";
 import type { CosmosToolboxParams } from "../types";
 import {
   cosmosCreateTransaction,
   createSigningStargateClient,
   createStargateClient,
+  getAssetFromDenom,
   getDenomWithChain,
   getMsgSendDenom,
 } from "../util";
@@ -38,8 +39,7 @@ export async function fetchFeeRateFromSwapKit(chainId: ChainId, safeDefault: num
     const responseGasRate = response.find((gas) => gas.chainId === chainId)?.value;
 
     return responseGasRate ? Number.parseFloat(responseGasRate) : safeDefault;
-  } catch (e) {
-    console.error(e);
+  } catch (_e) {
     return safeDefault;
   }
 }
@@ -52,8 +52,8 @@ export async function getSignerFromPhrase({
   | { chain: Chain; index?: number }
   | { derivationPath: string }
 )) {
-  const { DirectSecp256k1HdWallet } = await import("@cosmjs/proto-signing");
-  const { stringToPath } = await import("@cosmjs/crypto");
+  const { DirectSecp256k1HdWallet } = (await import("@cosmjs/proto-signing")).default;
+  const { stringToPath } = (await import("@cosmjs/crypto")).default;
 
   const derivationPath =
     "derivationPath" in derivationParams
@@ -73,7 +73,7 @@ export async function getSignerFromPrivateKey({
   privateKey: Uint8Array;
   prefix: string;
 }) {
-  const { DirectSecp256k1Wallet } = await import("@cosmjs/proto-signing");
+  const { DirectSecp256k1Wallet } = (await import("@cosmjs/proto-signing")).default;
 
   return DirectSecp256k1Wallet.fromKey(privateKey, prefix);
 }
@@ -97,7 +97,7 @@ export function verifySignature(getAccount: (address: string) => Promise<Account
   }) {
     const account = await getAccount(address);
     if (!account?.pubkey) throw new SwapKitError("toolbox_cosmos_verify_signature_no_pubkey");
-    const { Secp256k1Signature, Secp256k1 } = await import("@cosmjs/crypto");
+    const { Secp256k1Signature, Secp256k1 } = (await import("@cosmjs/crypto")).default;
 
     const secpSignature = Secp256k1Signature.fromFixedLength(base64.decode(signature));
     return Secp256k1.verifySignature(secpSignature, base64.decode(message), account.pubkey.value);
@@ -185,7 +185,21 @@ export async function createCosmosToolbox({ chain, ...toolboxParams }: CosmosToo
     transfer,
     getAddress,
     getAccount,
-    getBalance: getBalance(chain),
+    getBalance: async (address: string, _potentialScamFilter?: boolean) => {
+      const denomBalances = await cosmosBalanceDenomsGetter(rpcUrl)(address);
+      return await Promise.all(
+        denomBalances
+          .filter(({ denom }) => denom && !denom.includes("IBC/"))
+          .map(({ denom, amount }) => {
+            const fullDenom =
+              [Chain.THORChain, Chain.Maya].includes(chain) &&
+              (denom.includes("/") || denom.includes("˜"))
+                ? `${chain}.${denom}`
+                : denom;
+            return getAssetFromDenom(fullDenom, amount);
+          }),
+      );
+    },
     getSignerFromPhrase: async ({
       phrase,
       derivationPath,
@@ -197,7 +211,7 @@ export async function createCosmosToolbox({ chain, ...toolboxParams }: CosmosToo
         index,
       }),
     getSignerFromPrivateKey: async (privateKey: Uint8Array) => {
-      const { DirectSecp256k1Wallet } = await import("@cosmjs/proto-signing");
+      const { DirectSecp256k1Wallet } = (await import("@cosmjs/proto-signing")).default;
       return DirectSecp256k1Wallet.fromKey(privateKey, chainPrefix);
     },
     createPrivateKeyFromPhrase: createPrivateKeyFromPhrase(derivationPath),
@@ -217,8 +231,7 @@ export async function getFeeRateFromThorswap(chainId: ChainId, safeDefault: numb
     const responseGasRate = response.find((gas) => gas.chainId === chainId)?.value;
 
     return responseGasRate ? Number.parseFloat(responseGasRate) : safeDefault;
-  } catch (e) {
-    console.error(e);
+  } catch (_e) {
     return safeDefault;
   }
 }
@@ -262,8 +275,14 @@ async function getFees(chain: Chain, safeDefault: number) {
   const baseFee = await fetchFeeRateFromSwapKit(ChainToChainId[chain], safeDefault);
   return {
     average: SwapKitNumber.fromBigInt(BigInt(baseFee), BaseDecimal[chain]),
-    fast: SwapKitNumber.fromBigInt(BigInt(Math.floor(baseFee * 1.5)), BaseDecimal[chain]),
-    fastest: SwapKitNumber.fromBigInt(BigInt(Math.floor(baseFee * 2)), BaseDecimal[chain]),
+    fast: SwapKitNumber.fromBigInt(
+      BigInt(applyFeeMultiplier(baseFee, FeeOption.Fast, true)),
+      BaseDecimal[chain],
+    ),
+    fastest: SwapKitNumber.fromBigInt(
+      BigInt(applyFeeMultiplier(baseFee, FeeOption.Fastest, true)),
+      BaseDecimal[chain],
+    ),
   } as { [key in FeeOption]: SwapKitNumber };
 }
 
@@ -316,9 +335,9 @@ function cosmosBalanceDenomsGetter(rpcUrl: string) {
 
 function createPrivateKeyFromPhrase(derivationPath: string) {
   return async function createPrivateKeyFromPhrase(phrase: string) {
-    const { Bip39, EnglishMnemonic, Slip10, Slip10Curve, stringToPath } = await import(
-      "@cosmjs/crypto"
-    );
+    const { Bip39, EnglishMnemonic, Slip10, Slip10Curve, stringToPath } = (
+      await import("@cosmjs/crypto")
+    ).default;
 
     const mnemonicChecked = new EnglishMnemonic(phrase);
     const seed = await Bip39.mnemonicToSeed(mnemonicChecked);

package/src/cosmos/toolbox/index.ts

@@ -1,4 +1,4 @@
-import { Chain, type CosmosChain } from "@swapkit/helpers";
+import { Chain, type CosmosChain, SwapKitError } from "@swapkit/helpers";
 
 import type { CosmosToolboxParams } from "../types";
 import { createCosmosToolbox } from "./cosmos";
@@ -25,7 +25,7 @@ export const getCosmosToolbox = <T extends CosmosChain>(
       return createThorchainToolbox({ chain, ...params }) as CosmosToolboxes[T];
 
     default:
-      throw new Error(`Chain ${chain} is not supported`);
+      throw new SwapKitError("toolbox_cosmos_not_supported", { chain });
   }
 };
 

package/src/cosmos/toolbox/thorchain.ts

@@ -9,6 +9,7 @@ import {
   NetworkDerivationPath,
   RequestClient,
   SKConfig,
+  SwapKitError,
   SwapKitNumber,
   derivationPathToString,
   updateDerivationPath,
@@ -43,8 +44,8 @@ function secp256k1HdWalletFromMnemonic({
   derivationPath?: string;
 }) {
   return async function secp256k1HdWalletFromMnemonic(mnemonic: string, index = 0) {
-    const { Secp256k1HdWallet } = await import("@cosmjs/amino");
-    const { stringToPath } = await import("@cosmjs/crypto");
+    const { Secp256k1HdWallet } = (await import("@cosmjs/amino")).default;
+    const { stringToPath } = (await import("@cosmjs/crypto")).default;
 
     return Secp256k1HdWallet.fromMnemonic(mnemonic, {
       hdPaths: [stringToPath(`${derivationPath}/${index}`)],
@@ -114,8 +115,8 @@ function broadcastMultisigTx({
     threshold: number,
     bodyBytes: Uint8Array,
   ) {
-    const { encodeSecp256k1Pubkey, pubkeyToAddress } = await import("@cosmjs/amino");
-    const { makeMultisignedTxBytes } = await import("@cosmjs/stargate");
+    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);
@@ -142,7 +143,8 @@ function broadcastMultisigTx({
 }
 
 async function createMultisig(pubKeys: string[], threshold: number, noSortPubKeys = true) {
-  const { createMultisigThresholdPubkey, encodeSecp256k1Pubkey } = await import("@cosmjs/amino");
+  const { createMultisigThresholdPubkey, encodeSecp256k1Pubkey } = (await import("@cosmjs/amino"))
+    .default;
   return createMultisigThresholdPubkey(
     pubKeys.map((pubKey) => encodeSecp256k1Pubkey(base64.decode(pubKey))),
     threshold,
@@ -161,7 +163,7 @@ async function signWithPrivateKey({
   privateKey: Uint8Array;
   message: string;
 }) {
-  const { Secp256k1 } = await import("@cosmjs/crypto");
+  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)]));
@@ -209,7 +211,7 @@ export async function createThorchainToolbox({
       } = await RequestClient.get<ThorchainConstantsResponse>(constantsUrl);
 
       if (!nativeFee || Number.isNaN(nativeFee) || nativeFee < 0) {
-        throw new Error(`Invalid nativeFee: ${nativeFee.toString()}`);
+        throw new SwapKitError("toolbox_cosmos_invalid_fee", { nativeFee: nativeFee.toString() });
       }
 
       fee = new SwapKitNumber(nativeFee);
@@ -230,7 +232,7 @@ export async function createThorchainToolbox({
   }: 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 Error("Signer not defined");
+    if (!(sender && signer)) throw new SwapKitError("toolbox_cosmos_no_signer");
 
     const isAminoSigner = "signAmino" in signer;
     const registry = await createDefaultRegistry();
@@ -301,7 +303,7 @@ export async function createThorchainToolbox({
     signWithPrivateKey,
     transfer,
     pubkeyToAddress: async (pubkey: Pubkey) => {
-      const { pubkeyToAddress } = await import("@cosmjs/amino");
+      const { pubkeyToAddress } = (await import("@cosmjs/amino")).default;
       return pubkeyToAddress(pubkey, chainPrefix);
     },
   };

package/src/cosmos/util.ts

@@ -1,6 +1,14 @@
 import type { OfflineSigner } from "@cosmjs/proto-signing";
 import type { SigningStargateClientOptions } from "@cosmjs/stargate";
-import { AssetValue, Chain, ChainId, type CosmosChain, SKConfig } from "@swapkit/helpers";
+import {
+  AssetValue,
+  BaseDecimal,
+  Chain,
+  ChainId,
+  type CosmosChain,
+  SKConfig,
+  SwapKitError,
+} from "@swapkit/helpers";
 
 import type { CosmosCreateTransactionParams } from "./thorchainUtils";
 
@@ -69,7 +77,7 @@ export const getDenomWithChain = ({ symbol, chain }: AssetValue) => {
 };
 
 export async function createStargateClient(url: string) {
-  const { StargateClient } = await import("@cosmjs/stargate");
+  const { StargateClient } = (await import("@cosmjs/stargate")).default;
 
   return StargateClient.connect(url);
 }
@@ -79,7 +87,7 @@ export async function createSigningStargateClient(
   signer: any,
   optionsOrBaseGas: string | SigningStargateClientOptions = {},
 ) {
-  const { SigningStargateClient, GasPrice } = await import("@cosmjs/stargate");
+  const { SigningStargateClient, GasPrice } = (await import("@cosmjs/stargate")).default;
   const gasPrice = typeof optionsOrBaseGas === "string" ? optionsOrBaseGas : "0.0003uatom";
   const options = typeof optionsOrBaseGas === "string" ? {} : optionsOrBaseGas;
 
@@ -93,7 +101,7 @@ export async function createOfflineStargateClient(
   wallet: OfflineSigner,
   registry?: SigningStargateClientOptions,
 ) {
-  const { SigningStargateClient } = await import("@cosmjs/stargate");
+  const { SigningStargateClient } = (await import("@cosmjs/stargate")).default;
 
   return SigningStargateClient.offline(wallet, registry);
 }
@@ -126,7 +134,7 @@ const getTransferMsgTypeByChain = (chain: CosmosChain) => {
     case Chain.Kujira:
       return "/cosmos.bank.v1beta1.MsgSend";
     default:
-      throw new Error("Unsupported chain");
+      throw new SwapKitError("toolbox_cosmos_not_supported", { chain });
   }
 };
 
@@ -149,7 +157,7 @@ export const cosmosCreateTransaction = async ({
   const accountOnChain = await client.getAccount(sender);
 
   if (!accountOnChain) {
-    throw new Error("Account does not exist");
+    throw new SwapKitError("toolbox_cosmos_account_not_found", { sender });
   }
 
   const gasAsset = AssetValue.from({ chain });
@@ -178,3 +186,65 @@ export const cosmosCreateTransaction = async ({
     msgs: [{ typeUrl: getTransferMsgTypeByChain(chain as CosmosChain), value: msgSend }],
   };
 };
+
+// Map of known denoms to their asset configurations
+const DENOM_MAP = {
+  // THORChain denoms
+  rune: { chain: Chain.THORChain, decimals: BaseDecimal[Chain.THORChain] },
+  tcy: { asset: "THOR.TCY", decimals: BaseDecimal[Chain.THORChain] },
+  "x/kuji": { asset: "THOR.KUJI", decimals: BaseDecimal[Chain.THORChain] },
+
+  // Cosmos denoms
+  uatom: { chain: Chain.Cosmos, decimals: BaseDecimal[Chain.Cosmos] },
+  atom: { chain: Chain.Cosmos, decimals: BaseDecimal[Chain.Cosmos] },
+
+  // Maya denoms
+  cacao: { chain: Chain.Maya, decimals: 10 }, // Maya uses 10 decimals for CACAO
+  maya: { asset: `${Chain.Maya}.${Chain.Maya}`, decimals: 4 }, // MAYA token uses 4 decimals
+
+  // Kujira denoms
+  ukuji: { chain: Chain.Kujira, decimals: BaseDecimal[Chain.Kujira] },
+  kuji: { chain: Chain.Kujira, decimals: BaseDecimal[Chain.Kujira] },
+
+  // USK on Kujira (lowercase version of the factory denom)
+  [USK_KUJIRA_FACTORY_DENOM.toLowerCase()]: {
+    asset: `${Chain.Kujira}.USK`,
+    decimals: BaseDecimal[Chain.Kujira],
+  },
+};
+
+/**
+ * Converts a Cosmos denom and amount to an AssetValue with proper decimal handling
+ * @param denom - The denomination string
+ * @param amount - The amount in base units as a string
+ * @returns AssetValue with the correct decimal conversion
+ */
+export const getAssetFromDenom = (denom: string, amount: string) => {
+  const config = DENOM_MAP[denom.toLowerCase()];
+
+  if (!config) {
+    // For unknown denoms, default to 8 decimals (common for many Cosmos chains)
+    // This preserves the original behavior while using fromBaseDecimal
+    return AssetValue.from({
+      asset: denom,
+      value: amount,
+      fromBaseDecimal: 8,
+    });
+  }
+
+  const { chain, asset, decimals } = config;
+
+  const assetOrChain = (
+    chain
+      ? {
+          chain,
+        }
+      : { asset }
+  ) as { asset: string } | { chain: CosmosChain };
+
+  return AssetValue.from({
+    ...assetOrChain,
+    value: amount,
+    fromBaseDecimal: decimals,
+  });
+};

package/src/evm/__tests__/address-validation.test.ts

@@ -0,0 +1,86 @@
+import { beforeAll, describe, expect, test } from "bun:test";
+import { Chain } from "@swapkit/helpers";
+import { getEvmToolbox } from "../toolbox";
+
+const context: {
+  validateAddress: (address: string) => boolean;
+} = {} as any;
+
+beforeAll(async () => {
+  // Get EVM toolbox for address validation
+  const toolbox = await getEvmToolbox(Chain.Ethereum);
+  context.validateAddress = toolbox.validateAddress;
+});
+
+describe("EVM Address Validation", () => {
+  test("should validate valid EVM addresses", () => {
+    const validAddresses = [
+      "0xa052Ddf1c1739419B90FB7bf722843AD3e63114B", // User provided address
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC contract
+      "0x6d6e022eE439C8aB8B7a7dBb0576f8090319CDc6", // Test address
+      "0xE29E61479420Dd1029A9946710Ac31A0d140e77F", // Another valid address
+      "0x0000000000000000000000000000000000000000", // Zero address
+      "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF", // Max address
+      "0x1234567890123456789012345678901234567890", // Mixed case
+    ];
+
+    for (const address of validAddresses) {
+      expect(context.validateAddress(address)).toBe(true);
+    }
+  });
+
+  test("should reject invalid EVM addresses", () => {
+    const invalidAddresses = [
+      "", // Empty string
+      "invalid", // Random string
+      "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t", // TRON address
+      "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa", // Bitcoin address
+      "cosmos1abc123", // Cosmos address
+      "0xa052Ddf1c1739419B90FB7bf722843AD3e63114", // Too short (missing 1 char)
+      "0xa052Ddf1c1739419B90FB7bf722843AD3e63114BB", // Too long (extra char)
+      "0XA052DDF1C1739419B90FB7BF722843AD3E63114B", // Uppercase 0X prefix
+      "0xG052Ddf1c1739419B90FB7bf722843AD3e63114B", // Invalid hex character
+      "0x", // Only prefix
+    ];
+
+    for (const address of invalidAddresses) {
+      expect(context.validateAddress(address)).toBe(false);
+    }
+  });
+
+  test("should handle case normalization properly", () => {
+    const address = "0xa052Ddf1c1739419B90FB7bf722843AD3e63114B"; // Proper checksum
+    const lowerCase = address.toLowerCase();
+
+    // Valid case variations should be accepted
+    expect(context.validateAddress(address)).toBe(true);
+    expect(context.validateAddress(lowerCase)).toBe(true);
+  });
+
+  test("should reject invalid checksum addresses", () => {
+    const invalidChecksumAddress = "0xA052dDF1C1739419b90fb7BF722843ad3E63114b"; // Invalid checksum
+
+    // Should reject mixed case with invalid checksum
+    expect(context.validateAddress(invalidChecksumAddress)).toBe(false);
+  });
+
+  test("should handle edge cases", () => {
+    const edgeCases = [null, undefined, 123, {}, [], true, false];
+
+    for (const testCase of edgeCases) {
+      // Should not throw but return false for invalid inputs
+      expect(context.validateAddress(testCase as any)).toBe(false);
+    }
+  });
+
+  test("should validate checksummed addresses", () => {
+    const checksummedAddresses = [
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC with proper checksum
+      "0x6d6e022eE439C8aB8B7a7dBb0576f8090319CDc6", // Another checksummed address
+    ];
+
+    for (const address of checksummedAddresses) {
+      expect(context.validateAddress(address)).toBe(true);
+    }
+  });
+});

package/src/evm/__tests__/ethereum.test.ts

@@ -35,7 +35,7 @@ beforeEach(async () => {
     },
   });
   context.provider = provider;
-  context.toolbox = await getEvmToolbox(Chain.Ethereum, { provider, signer });
+  context.toolbox = await getEvmToolbox(Chain.Ethereum, { provider, signer: signer as any });
 });
 
 afterEach(async () => {

package/src/evm/helpers.ts

@@ -8,6 +8,7 @@ import {
   FeeOption,
   type NetworkParams,
   SKConfig,
+  SwapKitError,
   SwapKitNumber,
 } from "@swapkit/helpers";
 import type { BrowserProvider, Provider } from "ethers";
@@ -71,7 +72,7 @@ export const estimateMaxSendableAmount = async ({
   const isFeeEVMLegacyCompatible = "gasPrice" in gasRate && gasRate.gasPrice !== undefined;
 
   if (!(gasRate && (isFeeEVMLegacyCompatible || isFeeEIP1559Compatible))) {
-    throw new Error("Could not fetch fee data");
+    throw new SwapKitError("toolbox_evm_no_fee_data");
   }
 
   const gasPrice = isFeeEIP1559Compatible
@@ -116,7 +117,7 @@ export function getEstimateTransactionFee({
       return assetValue.set(SwapKitNumber.fromBigInt(fee, assetValue.decimal));
     }
 
-    throw new Error("No gas price found");
+    throw new SwapKitError("toolbox_evm_no_gas_price");
   };
 }
 
@@ -168,6 +169,6 @@ function getNetworkInfo<C extends EVMChain>({ chain }: { chain: C }) {
         nativeCurrency: { name: "Polygon", symbol: Chain.Polygon, decimals },
       };
     default:
-      throw new Error(`Chain ${chain} is not supported`);
+      throw new SwapKitError("toolbox_evm_not_supported", { chain });
   }
 }