@swapkit/helpers 1.0.0-rc.85 → 1.0.0-rc.87

package/src/types/chains.ts

@@ -0,0 +1,219 @@
+import { ExplorerUrl, RPCUrl } from "./network";
+
+export enum Chain {
+  Arbitrum = "ARB",
+  Avalanche = "AVAX",
+  Binance = "BNB",
+  BinanceSmartChain = "BSC",
+  Bitcoin = "BTC",
+  BitcoinCash = "BCH",
+  Cosmos = "GAIA",
+  Dash = "DASH",
+  Dogecoin = "DOGE",
+  Ethereum = "ETH",
+  Kujira = "KUJI",
+  Litecoin = "LTC",
+  Maya = "MAYA",
+  Optimism = "OP",
+  Polkadot = "DOT",
+  Chainflip = "FLIP",
+  Polygon = "MATIC",
+  THORChain = "THOR",
+}
+
+export enum ChainId {
+  Arbitrum = "42161",
+  ArbitrumHex = "0xa4b1",
+  Avalanche = "43114",
+  AvalancheHex = "0xa86a",
+  Binance = "Binance-Chain-Tigris",
+  BinanceSmartChain = "56",
+  BinanceSmartChainHex = "0x38",
+  Bitcoin = "bitcoin",
+  BitcoinCash = "bitcoincash",
+  Chainflip = "chainflip",
+  Cosmos = "cosmoshub-4",
+  Dash = "dash",
+  Dogecoin = "dogecoin",
+  Kujira = "kaiyo-1",
+  Ethereum = "1",
+  EthereumHex = "0x1",
+  Litecoin = "litecoin",
+  Maya = "mayachain-mainnet-v1",
+  MayaStagenet = "mayachain-stagenet-v1",
+  Optimism = "10",
+  OptimismHex = "0xa",
+  Polkadot = "polkadot",
+  Polygon = "137",
+  PolygonHex = "0x89",
+  THORChain = "thorchain-mainnet-v1",
+  THORChainStagenet = "thorchain-stagenet-v2",
+}
+
+export const ChainIdToChain: Record<ChainId, Chain> = {
+  [ChainId.ArbitrumHex]: Chain.Arbitrum,
+  [ChainId.Arbitrum]: Chain.Arbitrum,
+  [ChainId.AvalancheHex]: Chain.Avalanche,
+  [ChainId.Avalanche]: Chain.Avalanche,
+  [ChainId.BinanceSmartChainHex]: Chain.BinanceSmartChain,
+  [ChainId.BinanceSmartChain]: Chain.BinanceSmartChain,
+  [ChainId.Binance]: Chain.Binance,
+  [ChainId.BitcoinCash]: Chain.BitcoinCash,
+  [ChainId.Bitcoin]: Chain.Bitcoin,
+  [ChainId.Chainflip]: Chain.Chainflip,
+  [ChainId.Cosmos]: Chain.Cosmos,
+  [ChainId.Dash]: Chain.Dash,
+  [ChainId.Dogecoin]: Chain.Dogecoin,
+  [ChainId.EthereumHex]: Chain.Ethereum,
+  [ChainId.Kujira]: Chain.Kujira,
+  [ChainId.Ethereum]: Chain.Ethereum,
+  [ChainId.Litecoin]: Chain.Litecoin,
+  [ChainId.MayaStagenet]: Chain.Maya,
+  [ChainId.Maya]: Chain.Maya,
+  [ChainId.OptimismHex]: Chain.Optimism,
+  [ChainId.Optimism]: Chain.Optimism,
+  [ChainId.Polkadot]: Chain.Polkadot,
+  [ChainId.PolygonHex]: Chain.Polygon,
+  [ChainId.Polygon]: Chain.Polygon,
+  [ChainId.THORChainStagenet]: Chain.THORChain,
+  [ChainId.THORChain]: Chain.THORChain,
+};
+
+type ChainNameType = keyof typeof Chain;
+const chainNames = Object.keys(Chain) as ChainNameType[];
+const chains = Object.values(Chain) as Chain[];
+
+export enum BaseDecimal {
+  ARB = 18,
+  AVAX = 18,
+  BCH = 8,
+  BNB = 8,
+  BSC = 18,
+  BTC = 8,
+  DASH = 8,
+  DOGE = 8,
+  DOT = 10,
+  ETH = 18,
+  FLIP = 18,
+  GAIA = 6,
+  KUJI = 6,
+  LTC = 8,
+  MATIC = 18,
+  MAYA = 10,
+  OP = 18,
+  THOR = 8,
+  ZEC = 8,
+}
+
+export type SubstrateChain = Chain.Polkadot | Chain.Chainflip;
+export const SubstrateChains = [Chain.Polkadot, Chain.Chainflip];
+
+export type EVMChain =
+  | Chain.Ethereum
+  | Chain.Avalanche
+  | Chain.BinanceSmartChain
+  | Chain.Arbitrum
+  | Chain.Optimism
+  | Chain.Polygon;
+export const EVMChains = [
+  Chain.Ethereum,
+  Chain.Avalanche,
+  Chain.BinanceSmartChain,
+  Chain.Arbitrum,
+  Chain.Optimism,
+  Chain.Polygon,
+] as const;
+
+export type UTXOChain =
+  | Chain.Bitcoin
+  | Chain.BitcoinCash
+  | Chain.Dash
+  | Chain.Dogecoin
+  | Chain.Litecoin;
+export const UTXOChains = [
+  Chain.Bitcoin,
+  Chain.BitcoinCash,
+  Chain.Dash,
+  Chain.Dogecoin,
+  Chain.Litecoin,
+] as const;
+
+export type CosmosChain =
+  | Chain.Cosmos
+  | Chain.THORChain
+  | Chain.Binance
+  | Chain.Maya
+  | Chain.Kujira;
+export const CosmosChains = [
+  Chain.Cosmos,
+  Chain.THORChain,
+  Chain.Binance,
+  Chain.Maya,
+  Chain.Kujira,
+] as const;
+
+export const TCSupportedChains = [
+  Chain.Avalanche,
+  Chain.Binance,
+  Chain.BinanceSmartChain,
+  Chain.Bitcoin,
+  Chain.BitcoinCash,
+  Chain.Cosmos,
+  Chain.Dogecoin,
+  Chain.Ethereum,
+  Chain.Litecoin,
+  Chain.THORChain,
+] as const;
+
+export const MAYASupportedChains = [
+  Chain.Dash,
+  Chain.Ethereum,
+  Chain.Kujira,
+  Chain.Maya,
+  Chain.THORChain,
+] as const;
+
+const ChainToChainName = chains.reduce(
+  (acc, chain) => {
+    const chainName = chainNames.find((key) => Chain[key as ChainNameType] === chain);
+
+    if (chainName) acc[chain] = chainName;
+
+    return acc;
+  },
+  {} as { [key in Chain]: ChainNameType },
+);
+
+export const ChainToChainId = chains.reduce(
+  (acc, chain) => {
+    acc[chain] = ChainId[ChainToChainName[chain]];
+    return acc;
+  },
+  {} as { [key in Chain]: ChainId },
+);
+
+export const ChainToRPC = chains.reduce(
+  (acc, chain) => {
+    acc[chain] = RPCUrl[ChainToChainName[chain]];
+    return acc;
+  },
+  {} as { [key in Chain]: RPCUrl },
+);
+
+export const ChainToHexChainId = chains.reduce(
+  (acc, chain) => {
+    const chainString = `${ChainToChainName[chain]}Hex` as keyof typeof ChainId;
+
+    acc[chain] = ChainId[chainString];
+    return acc;
+  },
+  {} as { [key in Chain]: ChainId },
+);
+
+export const ChainToExplorerUrl = chains.reduce(
+  (acc, chain) => {
+    acc[chain] = ExplorerUrl[ChainToChainName[chain]];
+    return acc;
+  },
+  {} as { [key in Chain]: string },
+);

package/src/types/commonTypes.ts

@@ -0,0 +1,140 @@
+import type { Chain, CosmosChain, EVMChain, UTXOChain } from "./chains.ts";
+import type { WalletOption } from "./wallet.ts";
+
+type ConnectMethodNames =
+  | "connectEVMWallet"
+  | "connectKeplr"
+  | "connectKeystore"
+  | "connectKeepkey"
+  | "connectLedger"
+  | "connectOkx"
+  | "connectTrezor"
+  | "connectWalletconnect"
+  | "connectXDEFI";
+
+export type ConnectConfig = {
+  stagenet?: boolean;
+  /**
+   * @required
+   */
+  thorswapApiKey?: string;
+  /**
+   * @required for AVAX & BSC
+   */
+  covalentApiKey?: string;
+  /**
+   * @required for ETH
+   */
+  ethplorerApiKey?: string;
+  /**
+   * @required for BTC, BCH, LTC, DOGE
+   */
+  blockchairApiKey?: string;
+  /**
+   * @required for Walletconnect
+   */
+  walletConnectProjectId?: string;
+  /**
+   * @optional for Trezor config
+   */
+  trezorManifest?: {
+    email: string;
+    appUrl: string;
+  };
+  /**
+   * @optional for KeepKey config
+   */
+  keepkeyConfig?: {
+    apiKey: string;
+    pairingInfo: {
+      name: string;
+      imageUrl: string;
+      basePath: string;
+      url: string;
+    };
+  };
+};
+
+export type AddChainWalletParams<T extends Chain> = {
+  address: string;
+  balance: Todo[];
+  walletType: WalletOption;
+  chain: T;
+  [key: string]: Todo;
+};
+
+type ApisType = { [key in UTXOChain]?: string | Todo } & {
+  [key in EVMChain]?: string | Todo;
+} & {
+  [key in CosmosChain]?: string;
+};
+
+export type ConnectWalletParams = {
+  addChain: <T extends Chain>(params: AddChainWalletParams<T>) => void;
+  config: ConnectConfig;
+  rpcUrls: { [chain in Chain]?: string };
+  apis: ApisType;
+};
+
+export type Witness = {
+  value: number;
+  script: Buffer;
+};
+
+export type ExtendParams<WalletConnectMethodNames = ""> = {
+  excludedChains?: Chain[];
+  config?: ConnectConfig;
+  rpcUrls?: { [chain in Chain]?: string };
+  apis?: ApisType;
+  wallets: {
+    connectMethodName: ConnectMethodNames | WalletConnectMethodNames;
+    connect: (params: ConnectWalletParams) => (...params: Todo) => Promise<Todo>;
+  }[];
+};
+
+export enum QuoteMode {
+  TC_SUPPORTED_TO_TC_SUPPORTED = "TC-TC",
+  TC_SUPPORTED_TO_ETH = "TC-ERC20",
+  TC_SUPPORTED_TO_AVAX = "TC-ARC20",
+  TC_SUPPORTED_TO_BSC = "TC-BEP20",
+  ETH_TO_TC_SUPPORTED = "ERC20-TC",
+  ETH_TO_ETH = "ERC20-ERC20",
+  ETH_TO_AVAX = "ERC20-ARC20",
+  ETH_TO_BSC = "ERC20-BEP20",
+  AVAX_TO_TC_SUPPORTED = "ARC20-TC",
+  AVAX_TO_ETH = "ARC20-ERC20",
+  AVAX_TO_AVAX = "ARC20-ARC20",
+  AVAX_TO_BSC = "ARC20-BEP20",
+  BSC_TO_TC_SUPPORTED = "BEP20-TC",
+  BSC_TO_ETH = "BEP20-ERC20",
+  BSC_TO_AVAX = "BEP20-ARC20",
+  BSC_TO_BSC = "BEP20-BEP20",
+}
+
+export type Asset = {
+  chain: Chain;
+  symbol: string;
+  ticker: string;
+  synth?: boolean;
+};
+
+export const AGG_SWAP = [QuoteMode.ETH_TO_ETH, QuoteMode.AVAX_TO_AVAX, QuoteMode.BSC_TO_BSC];
+
+export const SWAP_IN = [
+  QuoteMode.ETH_TO_TC_SUPPORTED,
+  QuoteMode.ETH_TO_AVAX,
+  QuoteMode.ETH_TO_BSC,
+  QuoteMode.AVAX_TO_TC_SUPPORTED,
+  QuoteMode.AVAX_TO_ETH,
+  QuoteMode.AVAX_TO_BSC,
+  QuoteMode.BSC_TO_TC_SUPPORTED,
+  QuoteMode.BSC_TO_ETH,
+  QuoteMode.BSC_TO_AVAX,
+];
+
+export const SWAP_OUT = [
+  QuoteMode.TC_SUPPORTED_TO_TC_SUPPORTED,
+  QuoteMode.TC_SUPPORTED_TO_ETH,
+  QuoteMode.TC_SUPPORTED_TO_AVAX,
+  QuoteMode.TC_SUPPORTED_TO_BSC,
+];

package/src/types/derivationPath.ts

@@ -0,0 +1,56 @@
+import type { Chain } from "./chains";
+
+export enum ContractAddress {
+  ARB = "0x0000000000000000000000000000000000000000",
+  AVAX = "0x0000000000000000000000000000000000000000",
+  ETH = "0x0000000000000000000000000000000000000000",
+  BSC = "0x0000000000000000000000000000000000000000",
+  MATIC = "0x0000000000000000000000000000000000001010",
+  OP = "0x4200000000000000000000000000000000000042",
+}
+
+export enum DerivationPath {
+  ARB = "m/44'/60'/0'/0",
+  AVAX = "m/44'/60'/0'/0",
+  BCH = "m/44'/145'/0'/0",
+  BNB = "m/44'/714'/0'/0",
+  BSC = "m/44'/60'/0'/0",
+  BTC = "m/84'/0'/0'/0",
+  DASH = "m/44'/5'/0'/0",
+  DOGE = "m/44'/3'/0'/0",
+  DOT = "////",
+  ETH = "m/44'/60'/0'/0",
+  FLIP = "////",
+  GAIA = "m/44'/118'/0'/0",
+  KUJI = "m/44'/118'/0'/0",
+  LTC = "m/84'/2'/0'/0",
+  MATIC = "m/44'/60'/0'/0",
+  MAYA = "m/44'/931'/0'/0",
+  OP = "m/44'/60'/0'/0",
+  THOR = "m/44'/931'/0'/0",
+}
+
+export type DerivationPathArray = [number, number, number, number, number?];
+
+export const NetworkDerivationPath: Record<Chain, DerivationPathArray> = {
+  ARB: [44, 60, 0, 0, 0],
+  AVAX: [44, 60, 0, 0, 0],
+  BCH: [44, 145, 0, 0, 0],
+  BNB: [44, 714, 0, 0, 0],
+  BSC: [44, 60, 0, 0, 0],
+  BTC: [84, 0, 0, 0, 0],
+  DASH: [44, 5, 0, 0, 0],
+  DOGE: [44, 3, 0, 0, 0],
+  ETH: [44, 60, 0, 0, 0],
+  GAIA: [44, 118, 0, 0, 0],
+  KUJI: [44, 118, 0, 0, 0],
+  LTC: [84, 2, 0, 0, 0],
+  MATIC: [44, 60, 0, 0, 0],
+  MAYA: [44, 931, 0, 0, 0],
+  OP: [44, 60, 0, 0, 0],
+  THOR: [44, 931, 0, 0, 0],
+
+  // Polkadot and related network derivation path is not number based
+  DOT: [0, 0, 0, 0, 0],
+  FLIP: [0, 0, 0, 0, 0],
+};

package/src/types/index.ts

@@ -0,0 +1,10 @@
+export * from "./abis/erc20";
+export * from "./abis/tcEthVault";
+export * from "./chains";
+export * from "./commonTypes";
+export * from "./derivationPath";
+export * from "./network";
+export * from "./tokens";
+export * from "./transactions";
+export * from "./wallet";
+export * from "./sdk";

package/src/types/network.ts

@@ -0,0 +1,43 @@
+export enum RPCUrl {
+  Arbitrum = "https://arb1.arbitrum.io/rpc",
+  Avalanche = "https://node-router.thorswap.net/avalanche-c",
+  Binance = "",
+  BinanceSmartChain = "https://bsc-dataseed.binance.org",
+  Bitcoin = "https://node-router.thorswap.net/bitcoin",
+  BitcoinCash = "https://node-router.thorswap.net/bitcoin-cash",
+  Chainflip = "wss://mainnet-archive.chainflip.io",
+  Cosmos = "https://node-router.thorswap.net/cosmos/rpc",
+  Dash = "https://node-router.thorswap.net/dash",
+  Dogecoin = "https://node-router.thorswap.net/dogecoin",
+  Ethereum = "https://node-router.thorswap.net/ethereum",
+  Kujira = "https://rpc-kujira.synergynodes.com/",
+  Litecoin = "https://node-router.thorswap.net/litecoin",
+  Maya = "https://tendermint.mayachain.info",
+  MayaStagenet = "https://stagenet.tendermint.mayachain.info",
+  Optimism = "https://mainnet.optimism.io",
+  Polkadot = "wss://rpc.polkadot.io",
+  Polygon = "https://polygon-rpc.com",
+  THORChain = "https://rpc.thorswap.net",
+  THORChainStagenet = "https://stagenet-rpc.ninerealms.com",
+}
+
+export enum ExplorerUrl {
+  Arbitrum = "https://arbiscan.io",
+  Avalanche = "https://snowtrace.io",
+  Binance = "https://explorer.binance.org",
+  BinanceSmartChain = "https://bscscan.com",
+  Bitcoin = "https://blockchair.com/bitcoin",
+  BitcoinCash = "https://www.blockchair.com/bitcoin-cash",
+  Chainflip = "https://explorer.polkascan.io/polkadot",
+  Cosmos = "https://www.mintscan.io/cosmos",
+  Dash = "https://blockchair.com/dash",
+  Dogecoin = "https://blockchair.com/dogecoin",
+  Ethereum = "https://etherscan.io",
+  Kujira = "https://finder.kujira.network/kaiyo-1",
+  Litecoin = "https://blockchair.com/litecoin",
+  Maya = "https://www.mayascan.org",
+  Optimism = "https://optimistic.etherscan.io",
+  Polkadot = "https://polkadot.subscan.io/",
+  Polygon = "https://polygonscan.com",
+  THORChain = "https://runescan.io",
+}

package/src/types/sdk.ts

@@ -0,0 +1,32 @@
+import type { AssetValue } from "../modules/assetValue";
+
+export type PluginName = "thorchain" | "chainflip" | "mayachain";
+
+export type ProviderMethods = {
+  swap: (swapParams: SwapParams) => Promise<string>;
+  [key: string]: Todo;
+};
+
+export type SwapKitPlugins = {
+  [K in PluginName]?: ProviderMethods;
+};
+
+type GenericSwapParams = {
+  buyAsset: AssetValue;
+  sellAsset: AssetValue;
+  recipient: string;
+};
+
+export type SwapParams<T = GenericSwapParams> = T & {
+  provider?: {
+    name: PluginName;
+    config: Record<string, Todo>;
+  };
+};
+
+export type AvailableProviders<T> = T | { [K in PluginName]?: ProviderMethods };
+
+export type SwapKitPlugin = <T>({ wallets, stagenet }: { wallets: T; stagenet?: boolean }) => {
+  name: PluginName;
+  methods: ProviderMethods;
+};

package/src/types/transactions.ts

@@ -0,0 +1,71 @@
+import type { AssetValue } from "../modules/assetValue";
+
+export enum FeeOption {
+  Average = "average",
+  Fast = "fast",
+  Fastest = "fastest",
+}
+
+export enum ApproveMode {
+  Approve = "approve",
+  CheckOnly = "checkOnly",
+}
+
+export type ApproveReturnType<T extends ApproveMode> = T extends "checkOnly"
+  ? Promise<boolean>
+  : Promise<string>;
+
+export type WalletTxParams = {
+  feeOptionKey?: FeeOption;
+  from?: string;
+  memo?: string; // optional memo to pass
+  recipient: string;
+};
+
+export type EVMTxBaseParams<T = bigint> = {
+  to?: string;
+  from?: string;
+  nonce?: number;
+  gasLimit?: T;
+  data?: string;
+  value?: T;
+  chainId?: T;
+};
+
+export type GetAddressAndPubKeyResponse = {
+  bech32_address: string;
+  compressed_pk: NotWorth;
+  error_message: string;
+  return_code: number;
+};
+
+export type Signature = {
+  pub_key: {
+    type: string;
+    value: string;
+  };
+  sequence: string;
+  signature: string;
+};
+
+export enum MemoType {
+  BOND = "BOND",
+  DEPOSIT = "+",
+  LEAVE = "LEAVE",
+  THORNAME_REGISTER = "~",
+  UNBOND = "UNBOND",
+  WITHDRAW = "-",
+  OPEN_LOAN = "$+",
+  CLOSE_LOAN = "$-",
+}
+
+export type CoreTxParams = {
+  assetValue: AssetValue;
+  recipient: string;
+  memo?: string;
+  feeOptionKey?: FeeOption;
+  feeRate?: number;
+  data?: string;
+  from?: string;
+  expiration?: number;
+};

package/src/types/wallet.ts

@@ -0,0 +1,45 @@
+import type { AssetValue } from "../modules/assetValue";
+import type { Chain } from "./chains";
+
+export enum WalletOption {
+  KEYSTORE = "KEYSTORE",
+  KEEPKEY = "KEEPKEY",
+  XDEFI = "XDEFI",
+  METAMASK = "METAMASK",
+  COINBASE_WEB = "COINBASE_WEB",
+  TREZOR = "TREZOR",
+  TRUSTWALLET_WEB = "TRUSTWALLET_WEB",
+  LEDGER = "LEDGER",
+  KEPLR = "KEPLR",
+  OKX = "OKX",
+  OKX_MOBILE = "OKX_MOBILE",
+  BRAVE = "BRAVE",
+  WALLETCONNECT = "WALLETCONNECT",
+}
+
+export type EVMWalletOptions =
+  | WalletOption.BRAVE
+  | WalletOption.OKX_MOBILE
+  | WalletOption.METAMASK
+  | WalletOption.TRUSTWALLET_WEB
+  | WalletOption.COINBASE_WEB;
+
+export enum LedgerErrorCode {
+  NoError = 0x9000,
+  LockedDevice = 0x5515,
+  TC_NotFound = 65535,
+}
+
+export type ChainWallet = {
+  chain: Chain;
+  address: string;
+  balance: AssetValue[];
+  walletType: WalletOption;
+};
+
+export type EmptyWallet = { [key in Chain]?: unknown };
+
+export type BaseWallet<T extends EmptyWallet | unknown> = {
+  // @ts-expect-error
+  [key in Chain]: ChainWallet & T[key];
+};