@uswap/toolboxes 4.3.6

package/src/cosmos/types.ts

@@ -0,0 +1,48 @@
+import type { OfflineAminoSigner } from "@cosmjs/amino";
+import type { DirectSecp256k1HdWallet, OfflineDirectSigner } from "@cosmjs/proto-signing";
+import type {
+  ChainId,
+  CosmosChain,
+  DerivationPathArray,
+  GenericCreateTransactionParams,
+  TCLikeChain,
+} from "@uswap/helpers";
+import type { buildAminoMsg } from "./thorchainUtils";
+import type { createCosmosToolbox } from "./toolbox/cosmos";
+import type { createThorchainToolbox } from "./toolbox/thorchain";
+import type { getDefaultChainFee } from "./util";
+
+export type CosmosSDKClientParams = { server: string; chainId: ChainId; prefix?: string; stagenet?: boolean };
+export type CosmosCreateTransactionParams = GenericCreateTransactionParams & {
+  accountNumber?: number;
+  sequence?: number;
+};
+
+export type MultiSigSigner = { pubKey: string; signature: string };
+
+export type MultisigTx = {
+  msgs: ReturnType<typeof buildAminoMsg>[];
+  accountNumber: number;
+  sequence: number;
+  chainId: ChainId;
+  fee: ReturnType<typeof getDefaultChainFee>;
+  memo: string;
+};
+
+export type CosmosSigner = DirectSecp256k1HdWallet | OfflineDirectSigner | OfflineAminoSigner;
+
+export type CosmosToolboxParams<T = CosmosChain> = { chain: T } & (
+  | { signer?: CosmosSigner }
+  | { phrase?: string; derivationPath?: DerivationPathArray; index?: number }
+);
+
+export type BaseCosmosToolboxType = ReturnType<typeof createCosmosToolbox>;
+export type BaseCosmosWallet = Awaited<ReturnType<typeof createCosmosToolbox>>;
+export type CosmosWallets = {
+  [chain in Exclude<CosmosChain, TCLikeChain>]: BaseCosmosWallet;
+};
+
+export type ThorchainWallet = Awaited<Omit<ReturnType<typeof createThorchainToolbox>, "signMessage">>;
+export type ThorchainWallets = {
+  [chain in TCLikeChain]: ThorchainWallet;
+};

package/src/cosmos/util.ts

@@ -0,0 +1,214 @@
+import type { OfflineSigner } from "@cosmjs/proto-signing";
+import type { SigningStargateClientOptions } from "@cosmjs/stargate";
+import { AssetValue, Chain, type CosmosChain, getChainConfig, getRPCUrl, SwapKitError } from "@uswap/helpers";
+import type { CosmosCreateTransactionParams } from "./types";
+
+export const USK_KUJIRA_FACTORY_DENOM =
+  "FACTORY/KUJIRA1QK00H5ATUTPSV900X202PXX42NPJR9THG58DNQPA72F2P7M2LUASE444A7/UUSK";
+
+export const YUM_KUJIRA_FACTORY_DENOM = "FACTORY/KUJIRA1YGFXN0ER40KLCNCK8THLTUPRDXLCK6WVNPKF2K/UYUM";
+
+export const DEFAULT_COSMOS_FEE_MAINNET = { amount: [{ amount: "500", denom: "uatom" }], gas: "200000" };
+
+export const DEFAULT_KUJI_FEE_MAINNET = { amount: [{ amount: "1000", denom: "ukuji" }], gas: "200000" };
+
+export const DEFAULT_NOBLE_FEE_MAINNET = { amount: [{ amount: "1000", denom: "uusdc" }], gas: "200000" };
+
+export function getDefaultChainFee(chain: CosmosChain) {
+  switch (chain) {
+    case Chain.Maya:
+      return { amount: [], gas: "10000000000" };
+    case Chain.THORChain:
+      return { amount: [], gas: "500000000" };
+    case Chain.Kujira:
+      return DEFAULT_KUJI_FEE_MAINNET;
+    case Chain.Noble:
+      return DEFAULT_NOBLE_FEE_MAINNET;
+    default:
+      return DEFAULT_COSMOS_FEE_MAINNET;
+  }
+}
+
+export const getMsgSendDenom = (symbol: string, isThorchain = false) => {
+  if (isThorchain) {
+    return symbol.toLowerCase();
+  }
+
+  switch (symbol) {
+    case "uUSK":
+    case "USK":
+      return USK_KUJIRA_FACTORY_DENOM;
+    case "uYUM":
+    case "YUM":
+      return YUM_KUJIRA_FACTORY_DENOM;
+    case "uKUJI":
+    case "KUJI":
+      return "ukuji";
+    case "ATOM":
+    case "uATOM":
+      return "uatom";
+    case "uUSDC":
+    case "USDC":
+      return "uusdc";
+    default:
+      return symbol;
+  }
+};
+
+export const getDenomWithChain = ({ symbol, chain }: AssetValue) => {
+  if (chain === Chain.Maya) {
+    return (symbol.toUpperCase() !== "CACAO" ? symbol : `${Chain.Maya}.${symbol}`).toUpperCase();
+  }
+  if (chain === Chain.THORChain) {
+    return (
+      ["RUNE", "TCY", "RUJI"].includes(symbol.toUpperCase()) ? `${Chain.THORChain}.${symbol}` : symbol
+    ).toUpperCase();
+  }
+  return getMsgSendDenom(symbol, false);
+};
+
+export async function createStargateClient(url: string) {
+  const imported = await import("@cosmjs/stargate");
+
+  const StargateClient = imported.StargateClient ?? imported.default?.StargateClient;
+
+  const defaultRequestHeaders =
+    typeof window !== "undefined"
+      ? ({} as Record<string, string>)
+      : { referer: "https://sdk.swapkit.dev", referrer: "https://sdk.swapkit.dev" };
+
+  return StargateClient.connect({ headers: defaultRequestHeaders, url });
+}
+
+export async function createSigningStargateClient(
+  url: string,
+  signer: OfflineSigner,
+  optionsOrBaseGas: string | SigningStargateClientOptions = {},
+) {
+  const imported = await import("@cosmjs/stargate");
+  const SigningStargateClient = imported.SigningStargateClient ?? imported.default?.SigningStargateClient;
+  const GasPrice = imported.GasPrice ?? imported.default?.GasPrice;
+  const gasPrice = typeof optionsOrBaseGas === "string" ? optionsOrBaseGas : "0.0003uatom";
+  const options = typeof optionsOrBaseGas === "string" ? {} : optionsOrBaseGas;
+
+  return SigningStargateClient.connectWithSigner(url, signer, { gasPrice: GasPrice.fromString(gasPrice), ...options });
+}
+
+export async function createOfflineStargateClient(wallet: OfflineSigner, registry?: SigningStargateClientOptions) {
+  const imported = await import("@cosmjs/stargate");
+  const SigningStargateClient = imported.SigningStargateClient ?? imported.default?.SigningStargateClient;
+  return SigningStargateClient.offline(wallet, registry);
+}
+
+const getTransferMsgTypeByChain = (chain: CosmosChain) => {
+  switch (chain) {
+    case Chain.Maya:
+    case Chain.THORChain:
+      return "/types.MsgSend";
+    case Chain.Cosmos:
+    case Chain.Kujira:
+    case Chain.Noble:
+      return "/cosmos.bank.v1beta1.MsgSend";
+    default:
+      throw new SwapKitError("toolbox_cosmos_not_supported", { chain });
+  }
+};
+
+/**
+ * Used to build tx for Cosmos and Kujira
+ */
+export async function cosmosCreateTransaction({
+  sender,
+  recipient,
+  assetValue,
+  memo = "",
+  feeRate,
+  sequence,
+  accountNumber,
+}: CosmosCreateTransactionParams) {
+  const { chain, chainId } = assetValue;
+
+  const rpcUrl = await getRPCUrl(chain);
+  const client = await createStargateClient(rpcUrl);
+  const accountOnChain = await client.getAccount(sender);
+
+  if (!accountOnChain) {
+    throw new SwapKitError("toolbox_cosmos_account_not_found", { sender });
+  }
+
+  const gasAsset = AssetValue.from({ chain });
+  const feeAsset = getMsgSendDenom(gasAsset.symbol);
+  const defaultFee = getDefaultChainFee(chain as CosmosChain);
+
+  const txFee =
+    feeAsset && feeRate
+      ? { amount: [{ amount: feeRate.toString(), denom: feeAsset }], gas: defaultFee.gas }
+      : defaultFee;
+
+  const msgSend = {
+    amount: [{ amount: assetValue.getBaseValue("string"), denom: getMsgSendDenom(assetValue.symbol) }],
+    fromAddress: sender,
+    toAddress: recipient,
+  };
+
+  return {
+    accountNumber: accountNumber ?? accountOnChain.accountNumber,
+    chainId,
+    fee: txFee,
+    memo,
+    msgs: [{ typeUrl: getTransferMsgTypeByChain(chain as CosmosChain), value: msgSend }],
+    sequence: sequence ?? accountOnChain.sequence,
+  };
+}
+
+// Map of known denoms to their asset configurations
+const DENOM_MAP = {
+  atom: { chain: Chain.Cosmos, decimals: getChainConfig(Chain.Cosmos).baseDecimal },
+
+  // Maya denoms
+  cacao: { chain: Chain.Maya, decimals: 10 }, // Maya uses 10 decimals for CACAO
+  kuji: { chain: Chain.Kujira, decimals: getChainConfig(Chain.Kujira).baseDecimal },
+  maya: { asset: `${Chain.Maya}.${Chain.Maya}`, decimals: 4 }, // MAYA token uses 4 decimals
+  // THORChain denoms
+  rune: { chain: Chain.THORChain, decimals: getChainConfig(Chain.THORChain).baseDecimal },
+  tcy: { asset: "THOR.TCY", decimals: getChainConfig(Chain.THORChain).baseDecimal },
+
+  // Cosmos denoms
+  uatom: { chain: Chain.Cosmos, decimals: getChainConfig(Chain.Cosmos).baseDecimal },
+
+  // Kujira denoms
+  ukuji: { chain: Chain.Kujira, decimals: getChainConfig(Chain.Kujira).baseDecimal },
+  usdc: { chain: Chain.Noble, decimals: getChainConfig(Chain.Noble).baseDecimal },
+
+  // Noble denoms
+  uusdc: { chain: Chain.Noble, decimals: getChainConfig(Chain.Noble).baseDecimal },
+  "x/kuji": { asset: "THOR.KUJI", decimals: getChainConfig(Chain.THORChain).baseDecimal },
+
+  // USK on Kujira (lowercase version of the factory denom)
+  [USK_KUJIRA_FACTORY_DENOM.toLowerCase()]: {
+    asset: `${Chain.Kujira}.USK`,
+    decimals: getChainConfig(Chain.Kujira).baseDecimal,
+  },
+};
+
+/**
+ * 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, fromBaseDecimal: 8, value: amount });
+  }
+
+  const { chain, asset, decimals } = config;
+
+  const assetOrChain = (chain ? { chain } : { asset }) as { asset: string } | { chain: CosmosChain };
+
+  return AssetValue.from({ ...assetOrChain, fromBaseDecimal: decimals, value: amount });
+};

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

@@ -0,0 +1,84 @@
+import { beforeAll, describe, expect, test } from "bun:test";
+import { Chain } from "@uswap/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

@@ -0,0 +1,137 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { AssetValue, Chain, SKConfig } from "@uswap/helpers";
+import { erc20ABI } from "@uswap/helpers/contracts";
+import type { JsonRpcProvider, Signer } from "ethers";
+import { getEvmToolbox } from "../toolbox";
+
+// Import plugins for type augmentation
+import "@nomicfoundation/hardhat-ethers";
+import "@nomicfoundation/hardhat-network-helpers";
+
+// Set Hardhat config path to work from both root and package folder
+const __dirname = fileURLToPath(new URL(".", import.meta.url));
+const packageHardhatConfig = resolve(__dirname, "../../../hardhat.config.js");
+
+// Only set HARDHAT_CONFIG if not already set and if the config exists
+if (!process.env.HARDHAT_CONFIG && existsSync(packageHardhatConfig)) {
+  process.env.HARDHAT_CONFIG = packageHardhatConfig;
+}
+
+// Import hardhat after potentially setting the config path
+const { network } = await import("hardhat");
+
+const testAddress = "0x6d6e022eE439C8aB8B7a7dBb0576f8090319CDc6";
+const emptyRecipient = "0xE29E61479420Dd1029A9946710Ac31A0d140e77F";
+const USDCAddress = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+
+const context: { provider: JsonRpcProvider; signer: Signer; toolbox: Awaited<ReturnType<typeof getEvmToolbox>> } =
+  {} as any;
+
+beforeEach(async () => {
+  // Connect to Hardhat's in-process simulated network with forking (works in both local and CI)
+  // Must explicitly connect to 'hardhat' network to use the forking configuration
+  const connection = await network.connect("hardhat");
+
+  // Use Hardhat's simulated network provider directly
+  const provider = (connection as any).ethers.provider as JsonRpcProvider;
+  const signer = await (connection as any).ethers.getImpersonatedSigner(testAddress);
+
+  SKConfig.set({ apiKeys: { swapKit: process.env.TEST_API_KEY || Bun.env.TEST_API_KEY } });
+
+  context.provider = provider;
+  context.signer = signer as any;
+  context.toolbox = await getEvmToolbox(Chain.Ethereum, { provider, signer: signer as any });
+});
+
+describe("Ethereum toolkit", () => {
+  test.skip("Get Balances", async () => {
+    const balances = await context.toolbox.getBalance(testAddress);
+    expect(balances.find((balance) => balance.symbol === "ETH")?.getBaseValue("string")).toBe("20526000000000000");
+    expect(
+      balances
+        .find(
+          (balance) => balance.symbol.toLowerCase() === "USDC-0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48".toLowerCase(),
+        )
+        ?.getBaseValue("string"),
+    ).toBe("6656178");
+  }, 10000);
+
+  test("Send ETH", async () => {
+    expect((await context.provider.getBalance(emptyRecipient)).toString()).toBe("0");
+    await context.toolbox.transfer({
+      assetValue: AssetValue.from({ chain: Chain.Ethereum, value: "0.010526" }),
+      recipient: emptyRecipient,
+      sender: testAddress,
+    });
+    expect((await context.provider.getBalance(emptyRecipient)).toString()).toBe("10526000000000000");
+  }, 10000);
+
+  test(
+    "Send Token",
+    async () => {
+      const USDC = context.toolbox.createContract(USDCAddress, erc20ABI);
+      const balance = await USDC.balanceOf?.(emptyRecipient);
+      expect(balance.toString()).toBe("0");
+
+      await AssetValue.loadStaticAssets(["thorchain"]);
+
+      const assetValue = AssetValue.from({ asset: "ETH.USDC-0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", value: "1" });
+
+      await context.toolbox.transfer({ assetValue, recipient: emptyRecipient, sender: testAddress });
+      // biome-ignore lint/correctness/noUnsafeOptionalChaining: Tests
+      expect((await USDC.balanceOf?.(emptyRecipient)).toString()).toBe("1000000");
+    },
+    { retry: 3, timeout: 10000 },
+  );
+
+  test(
+    "Approve Token and validate approved amount",
+    async () => {
+      expect(
+        await context.toolbox.isApproved({
+          amount: "1000000",
+          assetAddress: USDCAddress,
+          from: testAddress,
+          spenderAddress: emptyRecipient,
+        }),
+      ).toBe(false);
+
+      await context.toolbox.approve({ amount: "1000000", assetAddress: USDCAddress, spenderAddress: emptyRecipient });
+
+      expect(
+        await context.toolbox.isApproved({
+          amount: "1000000",
+          assetAddress: USDCAddress,
+          from: testAddress,
+          spenderAddress: emptyRecipient,
+        }),
+      ).toBe(true);
+    },
+    { retry: 3, timeout: 10000 },
+  );
+
+  test(
+    "Create contract tx object and sendTransaction",
+    async () => {
+      const USDC = context.toolbox.createContract(USDCAddress, erc20ABI);
+      const balance = await USDC.balanceOf?.(emptyRecipient);
+      expect(balance.toString()).toBe("0");
+
+      const txObject = await context.toolbox.createContractTxObject({
+        abi: erc20ABI,
+        contractAddress: USDCAddress,
+        funcName: "transfer",
+        funcParams: [emptyRecipient, BigInt("2222222")],
+        txOverrides: { from: testAddress },
+      });
+
+      await context.toolbox.sendTransaction(txObject);
+      // biome-ignore lint/correctness/noUnsafeOptionalChaining: Tests
+      expect((await USDC?.balanceOf?.(emptyRecipient)).toString()).toBe("2222222");
+    },
+    { retry: 3, timeout: 10000 },
+  );
+});

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

@@ -0,0 +1,60 @@
+import { describe, expect, test } from "bun:test";
+import { Chain } from "@uswap/helpers";
+import { getEvmToolbox } from "../toolbox";
+
+const TEST_PHRASE = "test test test test test test test test test test test junk";
+const TEST_MESSAGE = "Hello, this is a test message for SIWE";
+const EXPECTED_ADDRESS = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
+
+describe("EVM signMessage", () => {
+  test("should sign message with phrase-based signer", async () => {
+    const toolbox = await getEvmToolbox(Chain.Ethereum, { phrase: TEST_PHRASE });
+
+    const address = await toolbox.getAddress();
+    expect(address).toBe(EXPECTED_ADDRESS);
+
+    const signature = await toolbox.signMessage?.(TEST_MESSAGE);
+
+    expect(signature).toBeDefined();
+    expect(typeof signature).toBe("string");
+  });
+
+  test("should sign Uint8Array message with phrase-based signer", async () => {
+    const toolbox = await getEvmToolbox(Chain.Ethereum, { phrase: TEST_PHRASE });
+
+    const messageBytes = new TextEncoder().encode(TEST_MESSAGE);
+    const signature = await toolbox.signMessage?.(messageBytes);
+
+    expect(signature).toBeDefined();
+    expect(typeof signature).toBe("string");
+  });
+
+  test("should produce consistent signatures for same message", async () => {
+    const toolbox = await getEvmToolbox(Chain.Ethereum, { phrase: TEST_PHRASE });
+
+    const signature1 = await toolbox.signMessage?.(TEST_MESSAGE);
+    const signature2 = await toolbox.signMessage?.(TEST_MESSAGE);
+
+    expect(signature1).toBeDefined();
+    expect(signature2).toBeDefined();
+    expect(signature1).toBe(signature2 as string);
+  });
+
+  test("should handle signMessage when no signer is present", async () => {
+    const toolbox = await getEvmToolbox(Chain.Ethereum);
+
+    expect(toolbox.signMessage).toBeUndefined();
+  });
+
+  test("should work with different EVM chains", async () => {
+    const chains = [Chain.Ethereum, Chain.Arbitrum, Chain.Polygon, Chain.BinanceSmartChain] as const;
+
+    for (const chain of chains) {
+      const toolbox = await getEvmToolbox(chain, { phrase: TEST_PHRASE });
+      const signature = await toolbox.signMessage?.(TEST_MESSAGE);
+
+      expect(signature).toBeDefined();
+      expect(typeof signature).toBe("string");
+    }
+  });
+});

package/src/evm/api.ts

@@ -0,0 +1,10 @@
+import type { EVMChain } from "@uswap/helpers";
+import { getBalance } from "../utils";
+
+export function getEvmApi(chain: EVMChain) {
+  return { getBalance: getBalance(chain) };
+}
+
+export function createCustomEvmApi(methods: ReturnType<typeof getEvmApi>) {
+  return methods;
+}