@swapkit/toolboxes 4.0.0-beta.50 → 4.0.0-beta.52

package/src/cosmos/toolbox/thorchain.ts

@@ -1,313 +0,0 @@
-import type { Pubkey, Secp256k1HdWallet } from "@cosmjs/amino";
-import { base64 } from "@scure/base";
-import {
-  BaseDecimal,
-  Chain,
-  CosmosChainPrefixes,
-  FeeOption,
-  type GenericTransferParams,
-  NetworkDerivationPath,
-  RequestClient,
-  SKConfig,
-  SwapKitError,
-  SwapKitNumber,
-  derivationPathToString,
-  updateDerivationPath,
-} from "@swapkit/helpers";
-
-import { P, match } from "ts-pattern";
-import {
-  buildAminoMsg,
-  buildEncodedTxBody,
-  convertToSignable,
-  createDefaultAminoTypes,
-  createDefaultRegistry,
-  getCreateTransaction,
-  parseAminoMessageForDirectSigning,
-} from "../thorchainUtils";
-import type { ThorchainConstantsResponse } from "../thorchainUtils/types/client-types";
-import type { MultisigTx } from "../types";
-import type { CosmosToolboxParams, MultiSigSigner } 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: Chain.THORChain | Chain.Maya) {
-  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, {
-      registry,
-      aminoTypes,
-    });
-    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,
-      sequence,
-      chainId,
-    });
-
-    const bodyBytes = await buildEncodedTxBody({
-      chain,
-      memo,
-      msgs: msgs.map(parseAminoMessageForDirectSigning),
-    });
-
-    return { signature: exportSignature(signature as Uint8Array), bodyBytes };
-  };
-}
-
-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<Chain.THORChain | Chain.Maya>) {
-  const nodeUrl = SKConfig.get("nodeUrls")[chain];
-  const rpcUrl = SKConfig.get("rpcUrls")[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({ phrase, derivationPath }),
-    )
-    .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({
-        value: isThorchain ? 0.02 : 1,
-        decimal: BaseDecimal[chain],
-      });
-    }
-
-    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, {
-      registry,
-      aminoTypes,
-    });
-
-    const aminoMessage = buildAminoMsg({
-      assetValue,
-      sender,
-      recipient,
-      memo,
-    });
-
-    if (isAminoSigner) {
-      const msgSign = await convertToSignable(aminoMessage, chain);
-
-      const { signatures, authInfoBytes } = await signingClient.sign(
-        sender,
-        [msgSign],
-        defaultFee,
-        memo,
-      );
-
-      const tx = TxRaw.encode({
-        signatures,
-        authInfoBytes,
-        bodyBytes: await buildEncodedTxBody({
-          chain,
-          msgs: [aminoMessage].map(parseAminoMessageForDirectSigning),
-          memo,
-        }),
-      }).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,
-    secp256k1HdWalletFromMnemonic: secp256k1HdWalletFromMnemonic({
-      derivationPath: derivationPathToString(derivationPath),
-      prefix: chainPrefix,
-    }),
-    signMultisigTx: signMultisigTx(chain),
-    signWithPrivateKey,
-    transfer,
-    pubkeyToAddress: async (pubkey: Pubkey) => {
-      const { pubkeyToAddress } = (await import("@cosmjs/amino")).default;
-      return pubkeyToAddress(pubkey, chainPrefix);
-    },
-  };
-}

package/src/cosmos/util.ts

@@ -1,266 +0,0 @@
-import type { OfflineSigner } from "@cosmjs/proto-signing";
-import type { SigningStargateClientOptions } from "@cosmjs/stargate";
-import {
-  AssetValue,
-  BaseDecimal,
-  Chain,
-  ChainId,
-  type CosmosChain,
-  SKConfig,
-  SwapKitError,
-} from "@swapkit/helpers";
-
-import type { CosmosCreateTransactionParams } from "./thorchainUtils";
-
-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: [{ denom: "uatom", amount: "500" }],
-  gas: "200000",
-};
-
-export const DEFAULT_KUJI_FEE_MAINNET = {
-  amount: [{ denom: "ukuji", amount: "1000" }],
-  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;
-    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";
-    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>)
-      : { referrer: "https://sdk.swapkit.dev", referer: "https://sdk.swapkit.dev" };
-
-  return StargateClient.connect({
-    url,
-    headers: defaultRequestHeaders,
-  });
-}
-
-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);
-}
-
-export const getRPC = (chainId: ChainId) => {
-  const { isStagenet } = SKConfig.get("envs");
-  const rpcUrls = SKConfig.get("rpcUrls");
-
-  switch (chainId) {
-    case ChainId.Kujira:
-      return rpcUrls.KUJI;
-
-    case ChainId.THORChain:
-    case "thorchain-mainnet-v1" as ChainId:
-      return isStagenet ? rpcUrls.THOR_STAGENET : rpcUrls.THOR;
-    case ChainId.Maya:
-      return isStagenet ? rpcUrls.MAYA_STAGENET : rpcUrls.MAYA;
-
-    default:
-      return rpcUrls.GAIA;
-  }
-};
-
-const getTransferMsgTypeByChain = (chain: CosmosChain) => {
-  switch (chain) {
-    case Chain.Maya:
-    case Chain.THORChain:
-      return "/types.MsgSend";
-    case Chain.Cosmos:
-    case Chain.Kujira:
-      return "/cosmos.bank.v1beta1.MsgSend";
-    default:
-      throw new SwapKitError("toolbox_cosmos_not_supported", { chain });
-  }
-};
-
-/**
- * Used to build tx for Cosmos and Kujira
- */
-export const cosmosCreateTransaction = async ({
-  sender,
-  recipient,
-  assetValue,
-  memo = "",
-  feeRate,
-  sequence,
-  accountNumber,
-}: CosmosCreateTransactionParams) => {
-  const { chain, chainId } = assetValue;
-
-  const url = getRPC(chainId);
-  const client = await createStargateClient(url);
-  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: [{ denom: feeAsset, amount: feeRate.toString() }], gas: defaultFee.gas }
-      : defaultFee;
-
-  const msgSend = {
-    fromAddress: sender,
-    toAddress: recipient,
-    amount: [
-      { amount: assetValue.getBaseValue("string"), denom: getMsgSendDenom(assetValue.symbol) },
-    ],
-  };
-
-  return {
-    accountNumber: accountNumber ?? accountOnChain.accountNumber,
-    chainId,
-    fee: txFee,
-    memo,
-    sequence: sequence ?? accountOnChain.sequence,
-    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

@@ -1,86 +0,0 @@
-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);
-    }
-  });
-});