@swapkit/toolboxes 4.2.1 → 4.3.3

package/src/cardano/toolbox.ts

@@ -0,0 +1,168 @@
+import { AssetValue, Chain, type DerivationPathArray, getChainConfig, SwapKitError } from "@swapkit/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 "@swapkit/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 "@swapkit/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";

package/src/cosmos/thorchainUtils/messages.ts

@@ -0,0 +1,212 @@
+import type { TxBodyEncodeObject } from "@cosmjs/proto-signing";
+import { AssetValue, Chain, getChainConfig, SwapKitError, type TCLikeChain } from "@swapkit/helpers";
+
+import { createStargateClient, getDefaultChainFee, getDenomWithChain, getMsgSendDenom } from "../util";
+
+import { createDefaultAminoTypes, createDefaultRegistry } from "./registry";
+import type { ThorchainCreateTransactionParams } from "./types";
+
+type MsgSend = ReturnType<typeof transferMsgAmino>;
+type MsgDeposit = ReturnType<typeof depositMsgAmino>;
+type DirectMsgSendForBroadcast = ReturnType<typeof parseAminoMessageForDirectSigning<MsgSend>>;
+type DirectMsgDepositForBroadcast = ReturnType<typeof parseAminoMessageForDirectSigning<MsgDeposit>>;
+
+export const THORCHAIN_GAS_VALUE = getDefaultChainFee(Chain.THORChain).gas;
+export const MAYA_GAS_VALUE = getDefaultChainFee(Chain.Maya).gas;
+
+export const transferMsgAmino = ({
+  sender,
+  recipient,
+  assetValue,
+}: {
+  sender: string;
+  recipient?: string;
+  assetValue: AssetValue;
+}) => {
+  const chain = assetValue.chain as typeof Chain.THORChain | typeof Chain.Maya;
+  return {
+    type: `${chain === Chain.Maya ? "mayachain" : "thorchain"}/MsgSend` as const,
+    value: {
+      amount: [{ amount: assetValue.getBaseValue("string"), denom: getMsgSendDenom(assetValue.symbol, true) }],
+      from_address: sender,
+      to_address: recipient,
+    },
+  };
+};
+
+export const depositMsgAmino = ({
+  sender,
+  assetValue,
+  memo = "",
+}: {
+  sender: string;
+  assetValue: AssetValue;
+  memo?: string;
+}) => {
+  const chain = assetValue.chain as TCLikeChain;
+  return {
+    type: `${chain === Chain.Maya ? "mayachain" : "thorchain"}/MsgDeposit` as const,
+    value: {
+      coins: [{ amount: assetValue.getBaseValue("string"), asset: getDenomWithChain(assetValue) }],
+      memo,
+      signer: sender,
+    },
+  };
+};
+
+export const buildAminoMsg = ({
+  sender,
+  recipient,
+  assetValue,
+  memo,
+}: {
+  sender: string;
+  recipient?: string;
+  assetValue: AssetValue;
+  memo?: string;
+}) => {
+  const isDeposit = !recipient;
+  const msg = isDeposit
+    ? depositMsgAmino({ assetValue, memo, sender })
+    : transferMsgAmino({ assetValue, recipient, sender });
+
+  return msg;
+};
+
+export const convertToSignable = async (msg: MsgSend | MsgDeposit, chain: TCLikeChain) => {
+  const aminoTypes = await createDefaultAminoTypes(chain);
+
+  return aminoTypes.fromAmino(msg);
+};
+
+const getAccount = async ({ rpcUrl, sender }: { sender: string; rpcUrl: string }) => {
+  const client = await createStargateClient(rpcUrl);
+  const account = await client.getAccount(sender);
+
+  if (!account) {
+    throw new SwapKitError("toolbox_cosmos_account_not_found", { sender });
+  }
+
+  return account;
+};
+
+export function getCreateTransaction(rpcUrl: string) {
+  return function createTransaction(params: ThorchainCreateTransactionParams) {
+    const { assetValue, recipient, memo, sender, asSignable, asAminoMessage } = params;
+
+    if (recipient) {
+      return buildTransferTx(rpcUrl)({ asAminoMessage, asSignable, assetValue, memo, recipient, sender });
+    }
+
+    return buildDepositTx(rpcUrl)({ asAminoMessage, asSignable, assetValue, memo, sender });
+  };
+}
+
+export const buildTransferTx =
+  (rpcUrl: string) =>
+  async ({
+    sender,
+    recipient,
+    assetValue,
+    memo = "",
+    asSignable = true,
+    asAminoMessage = false,
+    sequence,
+    accountNumber,
+  }: ThorchainCreateTransactionParams) => {
+    const account = await getAccount({ rpcUrl, sender });
+    const chain = assetValue.chain as TCLikeChain;
+    const { chainId } = getChainConfig(chain);
+
+    const transferMsg = transferMsgAmino({ assetValue, recipient, sender });
+
+    const msg = asSignable
+      ? await convertToSignable(asAminoMessage ? transferMsg : parseAminoMessageForDirectSigning(transferMsg), chain)
+      : transferMsg;
+
+    const transaction = {
+      accountNumber: accountNumber || account.accountNumber,
+      chainId,
+      fee: getDefaultChainFee(chain),
+      memo,
+      msgs: [msg],
+      sequence: sequence || account.sequence,
+    };
+
+    return transaction;
+  };
+
+export const buildDepositTx =
+  (rpcUrl: string) =>
+  async ({
+    sender,
+    assetValue,
+    memo = "",
+    asSignable = true,
+    asAminoMessage = false,
+    sequence,
+    accountNumber,
+  }: ThorchainCreateTransactionParams) => {
+    const account = await getAccount({ rpcUrl, sender });
+    const chain = assetValue.chain as TCLikeChain;
+    const { chainId } = getChainConfig(chain);
+
+    const depositMsg = depositMsgAmino({ assetValue, memo, sender });
+
+    const msg = asSignable
+      ? await convertToSignable(
+          asAminoMessage ? depositMsg : parseAminoMessageForDirectSigning<MsgDeposit>(depositMsg),
+          chain,
+        )
+      : depositMsg;
+
+    const transaction = {
+      accountNumber: accountNumber || account.accountNumber,
+      chainId,
+      fee: getDefaultChainFee(chain),
+      memo,
+      msgs: [msg],
+      sequence: sequence || account.sequence,
+    };
+
+    return transaction;
+  };
+
+export function parseAminoMessageForDirectSigning<T extends MsgDeposit | MsgSend>(msg: T) {
+  if (msg.type === "thorchain/MsgSend" || msg.type === "mayachain/MsgSend") return msg as MsgSend;
+
+  return {
+    ...msg,
+    value: {
+      ...msg.value,
+      coins: (msg as MsgDeposit).value.coins.map((coin: { asset: string; amount: string }) => {
+        const assetValue = AssetValue.from({ asset: coin.asset });
+
+        const symbol = (assetValue.isSynthetic ? assetValue.symbol.split("/")?.[1] : assetValue.symbol)?.toUpperCase();
+        const chain = (assetValue.isSynthetic ? assetValue.symbol.split("/")?.[0] : assetValue.chain)?.toUpperCase();
+
+        return { ...coin, asset: { chain, symbol, synth: assetValue.isSynthetic, ticker: assetValue.ticker } };
+      }),
+    },
+  };
+}
+
+export async function buildEncodedTxBody({
+  chain,
+  memo,
+  msgs,
+}: {
+  msgs: DirectMsgDepositForBroadcast[] | DirectMsgSendForBroadcast[];
+  memo: string;
+  chain: TCLikeChain;
+}) {
+  const registry = await createDefaultRegistry();
+  const aminoTypes = await createDefaultAminoTypes(chain);
+
+  const signedTxBody: TxBodyEncodeObject = {
+    typeUrl: "/cosmos.tx.v1beta1.TxBody",
+    value: { memo, messages: msgs.map((msg) => aminoTypes.fromAmino(msg)) },
+  };
+
+  return registry.encode(signedTxBody);
+}

package/src/cosmos/thorchainUtils/registry.ts

@@ -0,0 +1,43 @@
+import { Chain, type TCLikeChain } from "@swapkit/helpers";
+import { base64ToBech32, bech32ToBase64 } from "./addressFormat";
+
+export async function createDefaultRegistry() {
+  const { $root } = await import("./types/MsgCompiled");
+  const importedProtoSigning = await import("@cosmjs/proto-signing");
+  const Registry = importedProtoSigning.Registry ?? importedProtoSigning.default?.Registry;
+  const importedStargate = await import("@cosmjs/stargate");
+  const defaultRegistryTypes = importedStargate.defaultRegistryTypes ?? importedStargate.default?.defaultRegistryTypes;
+
+  return new Registry([
+    ...defaultRegistryTypes,
+    ["/types.MsgSend", $root.types.MsgSend],
+    ["/types.MsgDeposit", $root.types.MsgDeposit],
+  ]);
+}
+
+export async function createDefaultAminoTypes(chain: TCLikeChain) {
+  const imported = await import("@cosmjs/stargate");
+  const AminoTypes = imported.AminoTypes ?? imported.default?.AminoTypes;
+  const aminoTypePrefix = chain === Chain.THORChain ? "thorchain" : ("mayachain" as const);
+
+  return new AminoTypes({
+    "/types.MsgDeposit": {
+      aminoType: `${aminoTypePrefix}/MsgDeposit`,
+      fromAmino: ({ signer, ...rest }: any) => ({ ...rest, signer: bech32ToBase64(signer) }),
+      toAmino: ({ signer, ...rest }: any) => ({ ...rest, signer: base64ToBech32(signer) }),
+    },
+    "/types.MsgSend": {
+      aminoType: `${aminoTypePrefix}/MsgSend`,
+      fromAmino: ({ from_address, to_address, ...rest }: any) => ({
+        ...rest,
+        fromAddress: bech32ToBase64(from_address),
+        toAddress: bech32ToBase64(to_address),
+      }),
+      toAmino: ({ fromAddress, toAddress, ...rest }: any) => ({
+        ...rest,
+        from_address: base64ToBech32(fromAddress),
+        to_address: base64ToBech32(toAddress),
+      }),
+    },
+  });
+}