@swapkit/toolboxes 1.0.0-beta.0 → 1.0.0-beta.10

package/src/cosmos/thorchainUtils/util.ts

@@ -1,46 +0,0 @@
-import { type AssetValue, Chain, ChainId, SKConfig, StagenetChain } from "@swapkit/helpers";
-
-import { createStargateClient, getDenomWithChain } from "../util";
-import { bech32ToBase64 } from "./addressFormat";
-
-export const DEFAULT_GAS_VALUE = "5000000000";
-
-export const buildDepositTx = async ({
-  signer,
-  memo = "",
-  assetValue,
-}: {
-  signer: string;
-  memo?: string;
-  assetValue: AssetValue;
-}) => {
-  const { isStagenet } = SKConfig.get("envs");
-  const client = await createStargateClient(
-    SKConfig.get("rpcUrls")[isStagenet ? StagenetChain.THORChain : Chain.THORChain],
-  );
-  const accountOnChain = await client.getAccount(signer);
-
-  if (!accountOnChain) {
-    throw new Error("Account does not exist");
-  }
-
-  return {
-    memo,
-    accountNumber: accountOnChain.accountNumber,
-    chainId: ChainId.THORChain,
-    fee: { amount: [], gas: DEFAULT_GAS_VALUE },
-    sequence: accountOnChain.sequence,
-    msgs: [
-      {
-        typeUrl: "/types.MsgDeposit",
-        value: {
-          coins: [
-            { amount: assetValue.getBaseValue("string"), asset: getDenomWithChain(assetValue) },
-          ],
-          signer: bech32ToBase64(signer),
-          memo,
-        },
-      },
-    ],
-  };
-};

package/src/cosmos/toolbox/BaseCosmosToolbox.ts

@@ -1,254 +0,0 @@
-import { base64, bech32 } from "@scure/base";
-import {
-  AssetValue,
-  Chain,
-  type ChainId,
-  type CosmosChain,
-  CosmosChainPrefixes,
-  DerivationPath,
-  SKConfig,
-  SwapKitError,
-} from "@swapkit/helpers";
-import { SwapKitApi } from "@swapkit/helpers/api";
-
-import type { TransferParams } from "../types";
-import {
-  DEFAULT_COSMOS_FEE_MAINNET,
-  createSigningStargateClient,
-  createStargateClient,
-  getAssetFromDenom,
-  getMsgSendDenom,
-} from "../util";
-
-type Params = {
-  chain: CosmosChain;
-  derivationPath?: DerivationPath;
-  prefix?: string;
-  index?: number;
-};
-
-export async function getFeeRateFromThorswap(chainId: ChainId, safeDefault: number) {
-  try {
-    const response = await SwapKitApi.getGasRate();
-    const responseGasRate = response.find((gas) => gas.chainId === chainId)?.value;
-
-    return responseGasRate ? Number.parseFloat(responseGasRate) : safeDefault;
-  } catch (e) {
-    console.error(e);
-    return safeDefault;
-  }
-}
-
-export function BaseCosmosToolbox({
-  chain,
-  derivationPath: paramsDerivationPath,
-  index = 0,
-  prefix,
-}: Params) {
-  const rpcUrl = SKConfig.get("rpcUrls")[chain];
-  const chainPrefix = prefix || CosmosChainPrefixes[chain];
-  const derivationPath = paramsDerivationPath
-    ? `${paramsDerivationPath}/${index}`
-    : `${DerivationPath[chain]}/${index}`;
-
-  const getCosmosAccount = cosmosAccountGetter(chainPrefix);
-  const getCosmosBalance = cosmosBalanceGetter({ chain, rpcUrl });
-  const getCosmosBalanceAsDenoms = cosmosBalanceDenomsGetter(rpcUrl);
-
-  return {
-    transfer: cosmosTransfer(rpcUrl),
-    getSigner: async (phrase: string) => {
-      const { DirectSecp256k1HdWallet } = await import("@cosmjs/proto-signing");
-      const { stringToPath } = await import("@cosmjs/crypto");
-
-      return DirectSecp256k1HdWallet.fromMnemonic(phrase, {
-        prefix,
-        hdPaths: [stringToPath(derivationPath)],
-      });
-    },
-    getSignerFromPrivateKey: async (privateKey: Uint8Array) => {
-      const { DirectSecp256k1Wallet } = await import("@cosmjs/proto-signing");
-
-      return DirectSecp256k1Wallet.fromKey(privateKey, prefix);
-    },
-    createPrivateKeyFromPhrase: async (phrase: string) => {
-      const { Bip39, EnglishMnemonic, Slip10, Slip10Curve, stringToPath } = await import(
-        "@cosmjs/crypto"
-      );
-
-      const mnemonicChecked = new EnglishMnemonic(phrase);
-      const seed = await Bip39.mnemonicToSeed(mnemonicChecked);
-
-      const { privkey } = Slip10.derivePath(
-        Slip10Curve.Secp256k1,
-        seed,
-        stringToPath(derivationPath),
-      );
-
-      return privkey;
-    },
-    getAccount: async (address: string) => {
-      const client = await createStargateClient(rpcUrl);
-      return client.getAccount(address);
-    },
-    validateAddress: (address: string) => validateCosmosAddress({ prefix: chainPrefix, address }),
-    getAddressFromMnemonic: async (phrase: string) => {
-      const walletAccount = await getCosmosAccount({ phrase, derivationPath });
-
-      return walletAccount.address;
-    },
-    getPubKeyFromMnemonic: async (phrase: string) => {
-      const account = await getCosmosAccount({ phrase, derivationPath });
-      return base64.encode(account.pubkey);
-    },
-    getFeeRateFromThorswap,
-    getBalanceAsDenoms: getCosmosBalanceAsDenoms,
-    getBalance: getCosmosBalance,
-  };
-}
-
-export type BaseCosmosToolboxType = ReturnType<typeof BaseCosmosToolbox>;
-
-export function cosmosValidateAddress({
-  address,
-  chain,
-  prefix: chainPrefix,
-}: { address: string } & (
-  | { prefix: string; chain?: undefined }
-  | { chain: CosmosChain; prefix?: undefined }
-)) {
-  const prefix = chainPrefix || getPrefix(chain);
-
-  if (!(prefix && address)) {
-    throw new SwapKitError("toolbox_cosmos_validate_address_prefix_not_found");
-  }
-
-  return validateCosmosAddress({ prefix, address });
-}
-
-export function estimateTransactionFee({ assetValue: { chain } }: { assetValue: AssetValue }) {
-  return AssetValue.from({ chain, value: getMinTransactionFee(chain) });
-}
-
-export type BaseCosmosWallet = ReturnType<typeof BaseCosmosToolbox>;
-export type CosmosWallets = {
-  [chain in Chain.Cosmos | Chain.Kujira]: BaseCosmosWallet;
-};
-
-function getPrefix(chain?: CosmosChain) {
-  const { isStagenet } = SKConfig.get("envs");
-  const useStagenetPrefix = chain
-    ? [Chain.THORChain, Chain.Maya].includes(chain) && isStagenet
-    : false;
-  const basePrefix = chain ? CosmosChainPrefixes[chain] : undefined;
-
-  return useStagenetPrefix ? `s${basePrefix}` : basePrefix;
-}
-
-function getMinTransactionFee(chain: Chain) {
-  return (
-    {
-      [Chain.Cosmos]: 0.007,
-      [Chain.Kujira]: 0.02,
-      [Chain.THORChain]: 0.02,
-      [Chain.Maya]: 0.02,
-    }[chain as CosmosChain] || 0
-  );
-}
-
-function validateCosmosAddress({ prefix, address }: { prefix: string; address: string }) {
-  if (!address.startsWith(prefix)) return false;
-
-  try {
-    const { prefix, words } = bech32.decode(address as `${string}1${string}`);
-    const normalized = bech32.encode(prefix, words);
-
-    return normalized === address.toLocaleLowerCase();
-  } catch (_error) {
-    return false;
-  }
-}
-
-function cosmosTransfer(rpcUrl: string) {
-  return async function transfer({
-    from,
-    recipient,
-    assetValue,
-    memo = "",
-    fee = DEFAULT_COSMOS_FEE_MAINNET,
-    signer,
-  }: TransferParams) {
-    if (!signer) {
-      throw new SwapKitError("toolbox_cosmos_signer_not_defined");
-    }
-
-    const signingClient = await createSigningStargateClient(rpcUrl, signer);
-    const message = [
-      {
-        denom: getMsgSendDenom(`u${assetValue.symbol}`).toLowerCase(),
-        amount: assetValue.getBaseValue("string"),
-      },
-    ];
-
-    const { transactionHash } = await signingClient.sendTokens(from, recipient, message, fee, memo);
-
-    return transactionHash;
-  };
-}
-
-function cosmosBalanceDenomsGetter(rpcUrl: string) {
-  return async function getCosmosBalanceDenoms(address: string) {
-    const client = await createStargateClient(rpcUrl);
-    const allBalances = await client.getAllBalances(address);
-
-    const balances = allBalances.map((balance) => ({
-      ...balance,
-      denom: balance.denom.includes("/") ? balance.denom.toUpperCase() : balance.denom,
-    }));
-
-    return balances;
-  };
-}
-
-function cosmosBalanceGetter({ chain, rpcUrl }: { chain: Chain; rpcUrl: string }) {
-  return async function getCosmosBalance(
-    address: string,
-    // filterFunc?: (params: { denom: string; amount: string }) => boolean,
-  ) {
-    const denomBalances = await cosmosBalanceDenomsGetter(rpcUrl)(address);
-
-    const balances = denomBalances
-      .filter(({ denom }) => denom && !denom.includes("IBC/"))
-      .map(({ denom, amount }) => {
-        const fullDenom =
-          [Chain.THORChain, Chain.Maya].includes(chain) && denom.includes("/")
-            ? `${chain}.${denom}`
-            : denom;
-        return getAssetFromDenom(fullDenom, amount);
-      });
-
-    return balances;
-  };
-}
-
-function cosmosAccountGetter(prefix: string) {
-  return async function getCosmosAccount({
-    phrase,
-    derivationPath,
-  }: { phrase: string; derivationPath: string }) {
-    const { Secp256k1HdWallet } = await import("@cosmjs/amino");
-    const { stringToPath } = await import("@cosmjs/crypto");
-    const wallet = await Secp256k1HdWallet.fromMnemonic(phrase, {
-      prefix,
-      hdPaths: [stringToPath(derivationPath)],
-    });
-
-    const [account] = await wallet.getAccounts();
-
-    if (!account) {
-      throw new SwapKitError("toolbox_cosmos_no_accounts_found");
-    }
-
-    return account;
-  };
-}

package/src/cosmos/toolbox/gaia.ts

@@ -1,39 +0,0 @@
-import { BaseDecimal, Chain, ChainId, SwapKitNumber } from "@swapkit/helpers";
-
-import type { TransferParams } from "../types";
-
-import { buildNativeTransferTx } from "../util";
-import { BaseCosmosToolbox, getFeeRateFromThorswap } from "./BaseCosmosToolbox";
-
-export function GaiaToolbox() {
-  const cosmosToolbox = BaseCosmosToolbox({ chain: Chain.Cosmos });
-
-  async function getFees() {
-    const baseFee = await getFeeRateFromThorswap(ChainId.Cosmos, 500);
-    return {
-      type: "base",
-      average: SwapKitNumber.fromBigInt(BigInt(baseFee), BaseDecimal.GAIA),
-      fast: SwapKitNumber.fromBigInt((BigInt(baseFee) * 15n) / 10n, BaseDecimal.GAIA),
-      fastest: SwapKitNumber.fromBigInt(BigInt(baseFee) * 2n, BaseDecimal.GAIA),
-    };
-  }
-
-  async function transfer(params: TransferParams) {
-    const gasFees = await getFees();
-
-    return cosmosToolbox.transfer({
-      ...params,
-      fee: params.fee || {
-        amount: [
-          {
-            denom: "uatom",
-            amount: gasFees[params.feeOptionKey || "fast"].getBaseValue("string") || "1000",
-          },
-        ],
-        gas: "200000",
-      },
-    });
-  }
-
-  return { ...cosmosToolbox, getFees, transfer, buildTransferTx: buildNativeTransferTx };
-}

package/src/cosmos/toolbox/getToolboxByChain.ts

@@ -1,29 +0,0 @@
-import { Chain } from "@swapkit/helpers";
-
-import { GaiaToolbox } from "./gaia";
-import { KujiraToolbox } from "./kujira";
-import { MayaToolbox, ThorchainToolbox } from "./thorchain";
-
-export type CosmosToolboxType = {
-  THOR: typeof ThorchainToolbox;
-  GAIA: typeof GaiaToolbox;
-  KUJI: typeof KujiraToolbox;
-  MAYA: typeof MayaToolbox;
-};
-
-export const getToolboxByChain = <T extends keyof CosmosToolboxType>(
-  chain: T,
-): CosmosToolboxType[T] => {
-  switch (chain) {
-    case Chain.Kujira:
-      return KujiraToolbox as CosmosToolboxType[T];
-    case Chain.Maya:
-      return MayaToolbox as CosmosToolboxType[T];
-    case Chain.THORChain:
-      return ThorchainToolbox as CosmosToolboxType[T];
-    case Chain.Cosmos:
-      return GaiaToolbox as CosmosToolboxType[T];
-    default:
-      throw new Error(`Chain ${chain} is not supported`);
-  }
-};

package/src/cosmos/toolbox/kujira.ts

@@ -1,61 +0,0 @@
-import { BaseDecimal, Chain, ChainId, SwapKitNumber } from "@swapkit/helpers";
-
-import { USK_KUJIRA_FACTORY_DENOM, YUM_KUJIRA_FACTORY_DENOM } from "../index";
-import type { TransferParams } from "../types";
-import { buildNativeTransferTx, getAssetFromDenom } from "../util";
-
-import { BaseCosmosToolbox, getFeeRateFromThorswap } from "./BaseCosmosToolbox";
-
-async function getFees() {
-  const baseFee = await getFeeRateFromThorswap(ChainId.Kujira, 1000);
-  return {
-    type: "base",
-    average: SwapKitNumber.fromBigInt(BigInt(baseFee), BaseDecimal.KUJI),
-    fast: SwapKitNumber.fromBigInt(BigInt(Math.floor(baseFee * 1.5)), BaseDecimal.KUJI),
-    fastest: SwapKitNumber.fromBigInt(BigInt(Math.floor(baseFee * 2)), BaseDecimal.KUJI),
-  };
-}
-
-export const KujiraToolbox = () => {
-  const cosmosToolbox = BaseCosmosToolbox({ chain: Chain.Kujira });
-
-  return {
-    ...cosmosToolbox,
-    getFees,
-    buildTransferTx: buildNativeTransferTx,
-    getBalance: async (address: string, _potentialScamFilter?: boolean) => {
-      const denomBalances = await cosmosToolbox.getBalanceAsDenoms(address);
-
-      const balances = await Promise.all(
-        denomBalances
-          .filter(({ denom }) => {
-            if (!denom || denom.includes("IBC/")) return false;
-
-            return (
-              [USK_KUJIRA_FACTORY_DENOM, YUM_KUJIRA_FACTORY_DENOM].includes(denom) ||
-              !denom.startsWith("FACTORY")
-            );
-          })
-          .map(({ denom, amount }) => getAssetFromDenom(denom, amount)),
-      );
-
-      return balances;
-    },
-    transfer: async (params: TransferParams) => {
-      const gasFees = await getFees();
-
-      return cosmosToolbox.transfer({
-        ...params,
-        fee: params.fee || {
-          gas: "200000",
-          amount: [
-            {
-              denom: "ukuji",
-              amount: gasFees[params.feeOptionKey || "fast"].getBaseValue("string") || "1000",
-            },
-          ],
-        },
-      });
-    },
-  };
-};

package/src/evm/provider.ts

@@ -1,6 +0,0 @@
-import { type EVMChain, SKConfig } from "@swapkit/helpers";
-import { JsonRpcProvider } from "ethers";
-
-export const getProvider = (chain: EVMChain, customUrl?: string) => {
-  return new JsonRpcProvider(customUrl || SKConfig.get("rpcUrls")[chain]);
-};