@uswap/toolboxes 4.3.6

package/src/__tests__/address-validation-all-chains.test.ts

@@ -0,0 +1,162 @@
+import { beforeAll, describe, expect, test } from "bun:test";
+import { Chain } from "@uswap/helpers";
+import { getAddressValidator } from "../index";
+
+const context: { validateAddress: (params: { address: string; chain: Chain }) => boolean } = {} as any;
+
+beforeAll(async () => {
+  context.validateAddress = await getAddressValidator();
+});
+
+describe("Address Validation - All Chains", () => {
+  describe("Valid addresses for each chain", () => {
+    const validAddresses = {
+      [Chain.Ethereum]: ["0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0"],
+      [Chain.Avalanche]: ["0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0"],
+      [Chain.Arbitrum]: ["0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0"],
+      [Chain.BinanceSmartChain]: ["0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0"],
+      [Chain.Optimism]: ["0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0"],
+      [Chain.Polygon]: ["0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0"],
+      [Chain.Base]: ["0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0"],
+      [Chain.Bitcoin]: ["bc1qjpmp8xvg9k4ysa7nvev3lw7qcclvxzt2ex75kr", "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"],
+      [Chain.BitcoinCash]: ["qzhcfqxrnhcw88c433tq0fjlw0uut8c0e5d3cf8566"],
+      [Chain.Dogecoin]: ["DPrKsuhVibyfMMYRmKP49US5PBQR8zq6v4"],
+      [Chain.Litecoin]: ["ltc1qs4h7p8x0kfhs88wazmq2d40t59dwdlxd6rlpjz"],
+      [Chain.Dash]: ["XoBBveBZv32rq9MMBt88QSVsUtdj9cMCLy"],
+      [Chain.Zcash]: ["t1Mh7QW9g1gK94CSRxniD49aLAJ67s6UerX"],
+      [Chain.Cosmos]: ["cosmos12d7d2rlxp7urkp8z0p8sft2fm07ewyjrfvul3f"],
+      [Chain.Kujira]: ["kujira12d7d2rlxp7urkp8z0p8sft2fm07ewyjrcy78ur"],
+      [Chain.Maya]: ["maya1hm0sdz9v2h5jwjuu0ssp8x98upvlc6py2t7e6j"],
+      [Chain.Noble]: ["noble12d7d2rlxp7urkp8z0p8sft2fm07ewyjrp0fhf8"],
+      [Chain.THORChain]: ["thor1hm0sdz9v2h5jwjuu0ssp8x98upvlc6py2uq4vz"],
+      [Chain.Polkadot]: ["16kQVedQo7yYoFSp2MnQ78zP39xWnFGePnZps2APEyt9K9KZ"],
+      [Chain.Chainflip]: ["cFPctKfXisvnrhss2eMV2VdiUNRm1F5pX4WfqkcT3ZrLKJXrS"],
+      [Chain.Cardano]: [
+        "addr1qxk2md7wufs2cas0dfxch0uu59079s7yc5k9pw8s49wpm25s8ynu4svqm7m4hd04d4jvm6e5vvyw7dm4gvpqyfklgn8qetu85s",
+      ],
+      [Chain.Near]: ["a03fafdf5f97d3c6be6bff9e55f057dda76fefbb7e149f5469248f41e812cb6e"],
+      [Chain.Ripple]: ["rhDQXdwWR2RstC7sLjLMbjCeWT3PuSAZVu"],
+      [Chain.Solana]: ["4UHWuPwyV3XCcnwrpEdWAEW3WLUP1RDMaK3ANNsRUjfM"],
+      [Chain.Sui]: ["0x57b861db681d8e47b586e6e9a92f6ed210dbbb440670b8122420848cf0e844fb"],
+      [Chain.Ton]: ["EQCC1GV4iL5EkQqICYshf3AF7ESbceCYhVK-go1SkOMOBTNE"],
+      [Chain.Radix]: [] as string[],
+      [Chain.Harbor]: [] as string[],
+    };
+
+    for (const [chain, addresses] of Object.entries(validAddresses)) {
+      if (addresses.length === 0) continue;
+
+      test(`should validate valid ${chain} addresses`, () => {
+        for (const address of addresses) {
+          const result = context.validateAddress({ address, chain: chain as Chain });
+          expect(result).toBe(true);
+        }
+      });
+    }
+  });
+
+  describe("Invalid addresses should be rejected", () => {
+    const invalidTestCases: Array<{ chain: Chain; addresses: string[] }> = [
+      {
+        addresses: [
+          "",
+          "invalid",
+          "0x123",
+          "0xG051176f5F0B7ccC8fA0376F08aaa28F316A38a2a0",
+          "THr473cZqHwBLEmTWUUR1WTotxijWWbRGD",
+          "bc1qjpmp8xvg9k4ysa7nvev3lw7qcclvxzt2ex75kr",
+          "cosmos12d7d2rlxp7urkp8z0p8sft2fm07ewyjrfvul3f",
+        ],
+        chain: Chain.Ethereum,
+      },
+      {
+        addresses: [
+          "",
+          "invalid",
+          "0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0",
+          "THr473cZqHwBLEmTWUUR1WTotxijWWbRGD",
+          "cosmos12d7d2rlxp7urkp8z0p8sft2fm07ewyjrfvul3f",
+          "qzhcfqxrnhcw88c433tq0fjlw0uut8c0e5d3cf8566",
+        ],
+        chain: Chain.Bitcoin,
+      },
+      {
+        addresses: [
+          "",
+          "invalid",
+          "0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0",
+          "bc1qjpmp8xvg9k4ysa7nvev3lw7qcclvxzt2ex75kr",
+          "thor1hm0sdz9v2h5jwjuu0ssp8x98upvlc6py2uq4vz",
+          "maya1hm0sdz9v2h5jwjuu0ssp8x98upvlc6py2t7e6j",
+        ],
+        chain: Chain.Cosmos,
+      },
+      {
+        addresses: [
+          "",
+          "invalid",
+          "0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0",
+          "4UHWuPwyV3XCcnwrpEdWAEW3WLUP1RDMaK3ANNsRUjfM123",
+          "123",
+        ],
+        chain: Chain.Solana,
+      },
+      { addresses: ["", "invalid!"], chain: Chain.Near },
+      {
+        addresses: [
+          "",
+          "invalid",
+          "0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0",
+          "bc1qjpmp8xvg9k4ysa7nvev3lw7qcclvxzt2ex75kr",
+        ],
+        chain: Chain.Cardano,
+      },
+      {
+        addresses: [
+          "",
+          "invalid",
+          "0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0",
+          "bc1qjpmp8xvg9k4ysa7nvev3lw7qcclvxzt2ex75kr",
+        ],
+        chain: Chain.Ripple,
+      },
+    ];
+
+    for (const { chain, addresses } of invalidTestCases) {
+      test(`should reject invalid ${chain} addresses`, () => {
+        for (const address of addresses) {
+          const result = context.validateAddress({ address, chain });
+          expect(result).toBe(false);
+        }
+      });
+    }
+  });
+
+  describe("Edge cases and type safety", () => {
+    test("should handle non-string inputs safely", () => {
+      const edgeCases = [null, undefined, 123, {}, [], true, false];
+
+      for (const testCase of edgeCases) {
+        expect(context.validateAddress({ address: testCase as any, chain: Chain.Ethereum })).toBe(false);
+      }
+    });
+
+    test("should reject cross-chain address usage", () => {
+      expect(
+        context.validateAddress({ address: "0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0", chain: Chain.Bitcoin }),
+      ).toBe(false);
+
+      expect(
+        context.validateAddress({ address: "bc1qjpmp8xvg9k4ysa7nvev3lw7qcclvxzt2ex75kr", chain: Chain.Ethereum }),
+      ).toBe(false);
+
+      expect(
+        context.validateAddress({ address: "cosmos12d7d2rlxp7urkp8z0p8sft2fm07ewyjrfvul3f", chain: Chain.Maya }),
+      ).toBe(false);
+
+      expect(context.validateAddress({ address: "THr473cZqHwBLEmTWUUR1WTotxijWWbRGD", chain: Chain.Ethereum })).toBe(
+        false,
+      );
+    });
+  });
+});

package/src/__tests__/addressValidator.test.ts

@@ -0,0 +1,162 @@
+import { beforeAll, describe, expect, test } from "bun:test";
+import { Chain } from "@uswap/helpers";
+import { getAddressValidator } from "../index";
+
+const context: { validateAddress: (params: { address: string; chain: Chain }) => boolean } = {} as any;
+
+beforeAll(async () => {
+  context.validateAddress = await getAddressValidator();
+});
+
+describe("Address Validation - All Chains", () => {
+  describe("Valid addresses for each chain", () => {
+    const validAddresses = {
+      [Chain.Ethereum]: ["0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0"],
+      [Chain.Avalanche]: ["0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0"],
+      [Chain.Arbitrum]: ["0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0"],
+      [Chain.BinanceSmartChain]: ["0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0"],
+      [Chain.Optimism]: ["0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0"],
+      [Chain.Polygon]: ["0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0"],
+      [Chain.Base]: ["0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0"],
+      [Chain.Bitcoin]: ["bc1qjpmp8xvg9k4ysa7nvev3lw7qcclvxzt2ex75kr", "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"],
+      [Chain.BitcoinCash]: ["qzhcfqxrnhcw88c433tq0fjlw0uut8c0e5d3cf8566"],
+      [Chain.Dogecoin]: ["DPrKsuhVibyfMMYRmKP49US5PBQR8zq6v4"],
+      [Chain.Litecoin]: ["ltc1qs4h7p8x0kfhs88wazmq2d40t59dwdlxd6rlpjz"],
+      [Chain.Dash]: ["XoBBveBZv32rq9MMBt88QSVsUtdj9cMCLy"],
+      [Chain.Zcash]: ["t1Mh7QW9g1gK94CSRxniD49aLAJ67s6UerX"],
+      [Chain.Cosmos]: ["cosmos12d7d2rlxp7urkp8z0p8sft2fm07ewyjrfvul3f"],
+      [Chain.Kujira]: ["kujira12d7d2rlxp7urkp8z0p8sft2fm07ewyjrcy78ur"],
+      [Chain.Maya]: ["maya1hm0sdz9v2h5jwjuu0ssp8x98upvlc6py2t7e6j"],
+      [Chain.Noble]: ["noble12d7d2rlxp7urkp8z0p8sft2fm07ewyjrp0fhf8"],
+      [Chain.THORChain]: ["thor1hm0sdz9v2h5jwjuu0ssp8x98upvlc6py2uq4vz"],
+      [Chain.Polkadot]: ["16kQVedQo7yYoFSp2MnQ78zP39xWnFGePnZps2APEyt9K9KZ"],
+      [Chain.Chainflip]: ["cFPctKfXisvnrhss2eMV2VdiUNRm1F5pX4WfqkcT3ZrLKJXrS"],
+      [Chain.Cardano]: [
+        "addr1qxk2md7wufs2cas0dfxch0uu59079s7yc5k9pw8s49wpm25s8ynu4svqm7m4hd04d4jvm6e5vvyw7dm4gvpqyfklgn8qetu85s",
+      ],
+      [Chain.Near]: ["a03fafdf5f97d3c6be6bff9e55f057dda76fefbb7e149f5469248f41e812cb6e"],
+      [Chain.Ripple]: ["rhDQXdwWR2RstC7sLjLMbjCeWT3PuSAZVu"],
+      [Chain.Solana]: ["4UHWuPwyV3XCcnwrpEdWAEW3WLUP1RDMaK3ANNsRUjfM"],
+      [Chain.Sui]: ["0x57b861db681d8e47b586e6e9a92f6ed210dbbb440670b8122420848cf0e844fb"],
+      [Chain.Ton]: ["EQCC1GV4iL5EkQqICYshf3AF7ESbceCYhVK-go1SkOMOBTNE"],
+      [Chain.Radix]: [] as string[],
+      [Chain.Harbor]: [] as string[],
+    };
+
+    for (const [chain, addresses] of Object.entries(validAddresses)) {
+      if (addresses.length === 0) continue;
+
+      test(`should validate valid ${chain} addresses`, () => {
+        for (const address of addresses) {
+          const result = context.validateAddress({ address, chain: chain as Chain });
+          expect(result).toBe(true);
+        }
+      });
+    }
+  });
+
+  describe("Invalid addresses should be rejected", () => {
+    const invalidTestCases: Array<{ chain: Chain; addresses: string[] }> = [
+      {
+        addresses: [
+          "",
+          "invalid",
+          "0x123",
+          "0xG051176f5F0B7ccC8fA0376F08aaa28F316A38a2a0",
+          "THr473cZqHwBLEmTWUUR1WTotxijWWbRGD",
+          "bc1qjpmp8xvg9k4ysa7nvev3lw7qcclvxzt2ex75kr",
+          "cosmos12d7d2rlxp7urkp8z0p8sft2fm07ewyjrfvul3f",
+        ],
+        chain: Chain.Ethereum,
+      },
+      {
+        addresses: [
+          "",
+          "invalid",
+          "0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0",
+          "THr473cZqHwBLEmTWUUR1WTotxijWWbRGD",
+          "cosmos12d7d2rlxp7urkp8z0p8sft2fm07ewyjrfvul3f",
+          "qzhcfqxrnhcw88c433tq0fjlw0uut8c0e5d3cf8566",
+        ],
+        chain: Chain.Bitcoin,
+      },
+      {
+        addresses: [
+          "",
+          "invalid",
+          "0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0",
+          "bc1qjpmp8xvg9k4ysa7nvev3lw7qcclvxzt2ex75kr",
+          "thor1hm0sdz9v2h5jwjuu0ssp8x98upvlc6py2uq4vz",
+          "maya1hm0sdz9v2h5jwjuu0ssp8x98upvlc6py2t7e6j",
+        ],
+        chain: Chain.Cosmos,
+      },
+      {
+        addresses: [
+          "",
+          "invalid",
+          "0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0",
+          "4UHWuPwyV3XCcnwrpEdWAEW3WLUP1RDMaK3ANNsRUjfM123",
+          "123",
+        ],
+        chain: Chain.Solana,
+      },
+      { addresses: ["", "invalid!"], chain: Chain.Near },
+      {
+        addresses: [
+          "",
+          "invalid",
+          "0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0",
+          "bc1qjpmp8xvg9k4ysa7nvev3lw7qcclvxzt2ex75kr",
+        ],
+        chain: Chain.Cardano,
+      },
+      {
+        addresses: [
+          "",
+          "invalid",
+          "0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0",
+          "bc1qjpmp8xvg9k4ysa7nvev3lw7qcclvxzt2ex75kr",
+        ],
+        chain: Chain.Ripple,
+      },
+    ];
+
+    for (const { chain, addresses } of invalidTestCases) {
+      test(`should reject invalid ${chain} addresses`, () => {
+        for (const address of addresses) {
+          const result = context.validateAddress({ address, chain });
+          expect(result).toBe(false);
+        }
+      });
+    }
+  });
+
+  describe("Edge cases and type safety", () => {
+    test("should handle non-string inputs safely", () => {
+      const edgeCases = [null, undefined, 123, {}, [], true, false];
+
+      for (const testCase of edgeCases) {
+        expect(context.validateAddress({ address: testCase as any, chain: Chain.Ethereum })).toBe(false);
+      }
+    });
+
+    test("should reject cross-chain address usage", () => {
+      expect(
+        context.validateAddress({ address: "0x51176f5F0B7ccC8fA0376F08aaa28F316A38a2a0", chain: Chain.Bitcoin }),
+      ).toBe(false);
+
+      expect(
+        context.validateAddress({ address: "bc1qjpmp8xvg9k4ysa7nvev3lw7qcclvxzt2ex75kr", chain: Chain.Ethereum }),
+      ).toBe(false);
+
+      expect(
+        context.validateAddress({ address: "cosmos12d7d2rlxp7urkp8z0p8sft2fm07ewyjrfvul3f", chain: Chain.Maya }),
+      ).toBe(false);
+
+      expect(context.validateAddress({ address: "THr473cZqHwBLEmTWUUR1WTotxijWWbRGD", chain: Chain.Ethereum })).toBe(
+        false,
+      );
+    });
+  });
+});

package/src/cardano/__tests__/toolbox.test.ts

@@ -0,0 +1,48 @@
+import { beforeAll, describe, expect, test } from "bun:test";
+import { Chain } from "@uswap/helpers";
+import { getCardanoToolbox } from "../toolbox";
+
+const TEST_PHRASE = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
+
+const context: { toolbox: Awaited<ReturnType<typeof getCardanoToolbox>> } = {} as any;
+
+beforeAll(async () => {
+  context.toolbox = await getCardanoToolbox({ phrase: TEST_PHRASE });
+});
+
+describe("Cardano Toolbox", () => {
+  test("should validate valid Cardano addresses", () => {
+    const validAddresses = [
+      "addr_test1qz2fxv2umyhttkxyxp8x0dlpdt3k6cwng5pxj3jhsydzer3n0d3vllmyqwsx5wktcd8cc3sq835lu7drv2xwl2wywfgs68faae",
+    ];
+
+    for (const address of validAddresses) {
+      expect(context.toolbox.validateAddress(address)).toBe(true);
+    }
+  });
+
+  test("should reject invalid Cardano addresses", () => {
+    const invalidAddresses = [
+      "",
+      "invalid",
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+      "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+      "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
+    ];
+
+    for (const address of invalidAddresses) {
+      expect(context.toolbox.validateAddress(address)).toBe(false);
+    }
+  });
+
+  test("should generate valid Cardano address from phrase", () => {
+    const address = context.toolbox.getAddress();
+    expect(address.startsWith("addr")).toBe(true);
+  });
+
+  test("should estimate transaction fee", async () => {
+    const fee = await context.toolbox.estimateTransactionFee();
+    expect(fee.chain).toBe(Chain.Cardano);
+    expect(fee.getValue("number")).toBeGreaterThan(0);
+  });
+});

package/src/cardano/index.ts

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

package/src/cardano/toolbox.ts

@@ -0,0 +1,168 @@
+import { AssetValue, Chain, type DerivationPathArray, getChainConfig, SwapKitError } from "@uswap/helpers";
+import { match, P } from "ts-pattern";
+import type { CardanoProvider } from "./index";
+
+type CardanoSigner = CardanoProvider | { address: string };
+
+// TODO: this should done on BE side
+async function getProvider() {
+  const { BlockfrostProvider } = await import("@meshsdk/core");
+  const apiKey = "mainnet3YT7XK6NidLPlkHxxyBB5V0WzXUOTIJS"; // TODO: TEST API KEY
+  return new BlockfrostProvider(apiKey);
+}
+
+const ADA_ID = "lovelace";
+
+async function getCardanoBalance(address: string) {
+  try {
+    const { MeshWallet } = await import("@meshsdk/core");
+    const provider = await getProvider();
+
+    const wallet = new MeshWallet({ fetcher: provider, key: { address, type: "address" }, networkId: 1 });
+
+    await wallet.init();
+    const balance = await wallet.getBalance();
+
+    const balances: AssetValue[] = [];
+
+    for (const asset of balance) {
+      if (asset.unit === ADA_ID) {
+        const { baseDecimal } = getChainConfig(Chain.Cardano);
+        balances.push(AssetValue.from({ chain: Chain.Cardano, fromBaseDecimal: baseDecimal, value: asset.quantity }));
+      } else {
+        balances.push(AssetValue.from({ asset: `${Chain.Cardano}.${asset.unit}`, value: asset.quantity }));
+      }
+    }
+
+    if (balances.length === 0) {
+      return [AssetValue.from({ chain: Chain.Cardano })];
+    }
+
+    return balances;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`Cardano balance fetch error: ${errorMessage}`);
+    return [AssetValue.from({ chain: Chain.Cardano })];
+  }
+}
+
+export async function getCardanoAddressValidator() {
+  const { deserializeAddress } = await import("@meshsdk/core");
+
+  return (address: string) => {
+    try {
+      deserializeAddress(address);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+}
+
+export async function getCardanoToolbox(
+  toolboxParams?:
+    | { signer?: CardanoSigner }
+    | { phrase?: string; index?: number; derivationPath?: DerivationPathArray },
+) {
+  const validateAddress = await getCardanoAddressValidator();
+  const signer = await match(toolboxParams)
+    .with({ phrase: P.string }, async ({ phrase }) => {
+      const { MeshWallet } = await import("@meshsdk/core");
+      const provider = await getProvider();
+
+      const wallet = new MeshWallet({
+        fetcher: provider,
+        key: { type: "mnemonic", words: phrase.split(" ") },
+        networkId: 1,
+        submitter: provider,
+      });
+
+      await wallet.init();
+      return wallet;
+    })
+    .with({ signer: P.any }, ({ signer }) => signer)
+    .otherwise(() => undefined);
+
+  const signerAddress = signer && "getChangeAddress" in signer ? await signer.getChangeAddress() : "";
+
+  function getAddress() {
+    return signerAddress || "";
+  }
+
+  function getBalance(addressParam?: string) {
+    const address = addressParam || getAddress();
+    if (!address) throw new SwapKitError("core_wallet_connection_not_found");
+    return getCardanoBalance(address);
+  }
+
+  function estimateTransactionFee() {
+    return Promise.resolve(AssetValue.from({ chain: Chain.Cardano, value: "0.01" }));
+  }
+
+  async function createTransaction({
+    recipient,
+    assetValue,
+    memo,
+  }: {
+    recipient: string;
+    assetValue: AssetValue;
+    memo?: string;
+  }) {
+    if (!signer || !("getChangeAddress" in signer)) {
+      throw new SwapKitError("core_wallet_connection_not_found");
+    }
+    const { Transaction } = await import("@meshsdk/core");
+
+    const [, policyId] = assetValue.symbol.split("-");
+    if (!assetValue.isGasAsset && !policyId) throw new SwapKitError("core_wallet_connection_not_found");
+
+    const tx = new Transaction({ initiator: signer });
+    tx.sendAssets({ address: recipient }, [
+      { quantity: assetValue.getBaseValue("string"), unit: assetValue.isGasAsset ? "lovelace" : assetValue.symbol },
+    ]);
+
+    if (memo) tx.setMetadata(0, memo);
+
+    const unsignedTx = await tx.build();
+    return { tx, unsignedTx };
+  }
+
+  function signTransaction(txParams: string) {
+    if (!signer || !("getChangeAddress" in signer)) {
+      throw new SwapKitError("core_wallet_connection_not_found");
+    }
+
+    return signer.signTx(txParams);
+  }
+
+  async function transfer({
+    recipient,
+    assetValue,
+    memo,
+  }: {
+    recipient: string;
+    assetValue: AssetValue;
+    memo?: string;
+  }) {
+    if (!signer || !("getChangeAddress" in signer)) {
+      throw new SwapKitError("core_wallet_connection_not_found");
+    }
+
+    const { unsignedTx } = await createTransaction({ assetValue, memo, recipient });
+    const signedTx = await signTransaction(unsignedTx);
+    const provider = await getProvider();
+    const txHash = await provider.submitTx(signedTx);
+
+    return txHash;
+  }
+
+  return {
+    createTransaction,
+    estimateTransactionFee,
+    getAddress,
+    getBalance,
+    signTransaction,
+    transfer,
+    validateAddress,
+  };
+}

package/src/cardano/types.ts

@@ -0,0 +1,10 @@
+import type { getCardanoToolbox } from "./toolbox";
+
+export type CardanoWallet = Awaited<ReturnType<typeof getCardanoToolbox>>;
+
+export interface CardanoProvider {
+  connect: () => Promise<{ address: string }>;
+  disconnect: () => Promise<void>;
+  address: string | null;
+  signTransaction: (transaction: any) => Promise<any>;
+}

package/src/cosmos/__tests__/toolbox.test.ts

@@ -0,0 +1,91 @@
+import { beforeAll, describe, expect, test } from "bun:test";
+import { AssetValue, Chain } from "@uswap/helpers";
+import { getCosmosToolbox } from "../toolbox";
+
+const TEST_PHRASE = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
+const KNOWN_COSMOS_ADDRESS = "cosmos1r5v5srda7xfth3hn2s26txvrcrntldjumt8mhl";
+
+const context: { toolbox: Awaited<ReturnType<typeof getCosmosToolbox>> } = {} as any;
+
+beforeAll(async () => {
+  context.toolbox = await getCosmosToolbox(Chain.Cosmos, { phrase: TEST_PHRASE });
+});
+
+describe("Cosmos Toolbox", () => {
+  test("should validate valid Cosmos addresses", () => {
+    const validAddresses = [
+      KNOWN_COSMOS_ADDRESS,
+      "cosmos12d7d2rlxp7urkp8z0p8sft2fm07ewyjrfvul3f",
+      "cosmos1xv9tklw7d82sezh9haa573wufgy59vmwe6xxe5",
+    ];
+
+    for (const address of validAddresses) {
+      expect(context.toolbox.validateAddress(address)).toBe(true);
+    }
+  });
+
+  test("should reject invalid Cosmos addresses", () => {
+    const invalidAddresses = [
+      "",
+      "invalid",
+      "thor1xv9tklw7d82sezh9haa573wufgy59vmwzp5v3k",
+      "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+      "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
+      "cosmos1invalid",
+    ];
+
+    for (const address of invalidAddresses) {
+      expect(context.toolbox.validateAddress(address)).toBe(false);
+    }
+  });
+
+  test("should generate valid Cosmos address from phrase", async () => {
+    const address = await context.toolbox.getAddress();
+    if (address) {
+      expect(address.startsWith("cosmos1")).toBe(true);
+      expect(context.toolbox.validateAddress(address)).toBe(true);
+    }
+  });
+
+  test("should use 6 decimals for ATOM", () => {
+    const atomValue = AssetValue.from({ chain: Chain.Cosmos, value: 3.2 });
+
+    expect(atomValue.decimal).toBe(6);
+    expect(atomValue.getBaseValue("string")).toBe("3200000");
+  });
+
+  test("should convert ATOM amounts correctly with 6 decimals", () => {
+    const testCases = [
+      { amount: 0.1, expectedBase: "100000" },
+      { amount: 1, expectedBase: "1000000" },
+      { amount: 3.2, expectedBase: "3200000" },
+      { amount: 10.5, expectedBase: "10500000" },
+      { amount: 100, expectedBase: "100000000" },
+      { amount: 0.000001, expectedBase: "1" },
+    ];
+
+    for (const { amount, expectedBase } of testCases) {
+      const atomValue = AssetValue.from({ chain: Chain.Cosmos, value: amount });
+      expect(atomValue).toMatchObject({ decimal: 6 });
+      expect(atomValue.getBaseValue("string")).toBe(expectedBase);
+    }
+  });
+
+  test("should fetch balance for known address", async () => {
+    const balances = await context.toolbox.getBalance(KNOWN_COSMOS_ADDRESS);
+    expect(balances[0]).toMatchObject({ chain: Chain.Cosmos, decimal: 6, symbol: "ATOM" });
+  });
+
+  test("should not have 8 decimal bug (would be 100x too much)", () => {
+    const atomValue = AssetValue.from({ chain: Chain.Cosmos, value: 3.2 });
+    expect(Number.parseInt(atomValue.getBaseValue("string"), 10)).toBe(3200000);
+  });
+
+  test("should have minimum fee of 1000 uatom to meet network requirements", async () => {
+    const fees = await context.toolbox.getFees();
+
+    expect(fees.average.getBaseValue("number")).toBeGreaterThanOrEqual(1000);
+    expect(fees.fast.getBaseValue("number")).toBeGreaterThanOrEqual(1000);
+    expect(fees.fastest.getBaseValue("number")).toBeGreaterThanOrEqual(1000);
+  });
+});

package/src/cosmos/index.ts

@@ -0,0 +1,4 @@
+export * from "./thorchainUtils";
+export * from "./toolbox";
+export * from "./types";
+export * from "./util";

package/src/cosmos/thorchainUtils/addressFormat.ts

@@ -0,0 +1,22 @@
+import { base64, bech32 } from "@scure/base";
+import { SwapKitError } from "@uswap/helpers";
+import { fromByteArray, toByteArray } from "base64-js";
+
+export function bech32ToBase64(address: string) {
+  return base64.encode(Uint8Array.from(bech32.fromWords(bech32.decode(address as `${string}1${string}`).words)));
+}
+
+export function base64ToBech32(address: string, prefix = "thor") {
+  return bech32.encode(prefix, bech32.toWords(base64.decode(address)));
+}
+
+export function toBase64(data: Uint8Array) {
+  return fromByteArray(data);
+}
+
+export function fromBase64(base64String: string) {
+  if (!base64String.match(/^[a-zA-Z0-9+/]*={0,2}$/)) {
+    throw new SwapKitError("toolbox_cosmos_invalid_params", { error: "Invalid base64 string format" });
+  }
+  return toByteArray(base64String);
+}

package/src/cosmos/thorchainUtils/index.ts

@@ -0,0 +1,4 @@
+export * from "./addressFormat";
+export * from "./messages";
+export * from "./registry";
+export * from "./types";