@coinmasters/types 1.0.0

package/src/commonTypes.ts

@@ -0,0 +1,132 @@
+import type { FixedNumber } from 'ethers';
+
+import type { Chain, CosmosChain, EVMChain, UTXOChain } from './network.ts';
+import type { WalletOption } from './wallet.ts';
+
+type ConnectMethodNames =
+  | 'connectEVMWallet'
+  | 'connectKeplr'
+  | 'connectKeystore'
+  | 'connectKeepkey'
+  | 'connectLedger'
+  | 'connectOkx'
+  | 'connectTrezor'
+  | 'connectWalletconnect'
+  | 'connectXDEFI';
+
+type ChainWallet = {
+  address: string;
+  balance: any[];
+  walletType: WalletOption;
+};
+
+export type ConnectConfig = {
+  stagenet?: boolean;
+  /**
+   * @required for AVAX & BSC
+   */
+  covalentApiKey?: string;
+  /**
+   * @required for ETH
+   */
+  ethplorerApiKey?: string;
+  /**
+   * @required for BTC, LTC, DOGE & BCH
+   */
+  utxoApiKey?: string;
+  /**
+   * @required for Walletconnect
+   */
+  walletConnectProjectId?: string;
+  /**
+   * @optional for Trezor config
+   */
+  trezorManifest?: {
+    email: string;
+    appUrl: string;
+  };
+};
+
+export type AddChainWalletParams = {
+  chain: Chain;
+  wallet: ChainWallet;
+  walletMethods: any;
+};
+
+export type Witness = {
+  value: number;
+  script: Buffer;
+};
+
+export type FixedNumberish = string | number | FixedNumber;
+
+type ApisType = { [key in UTXOChain]?: string | any } & {
+  [key in EVMChain]?: string | any;
+} & {
+  [key in CosmosChain]?: string;
+};
+
+export type ConnectWalletParams = {
+  addChain: (params: AddChainWalletParams) => void;
+  config: ConnectConfig;
+  rpcUrls: { [chain in Chain]?: string };
+  apis: ApisType;
+};
+
+export type ExtendParams<WalletConnectMethodNames = ''> = {
+  excludedChains?: Chain[];
+  config?: ConnectConfig;
+  rpcUrls?: { [chain in Chain]?: string };
+  apis?: ApisType;
+  wallets: {
+    connectMethodName: ConnectMethodNames | WalletConnectMethodNames;
+    connect: (params: ConnectWalletParams) => (...params: any) => Promise<any>;
+  }[];
+};
+
+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/errors/apiError.ts

@@ -0,0 +1,75 @@
+import { getDisplayMessage } from './displayMessages.ts';
+import type { ApiErrorOptions, ERROR_CODE, ERROR_MODULE, ErrorInfo } from './types.ts';
+import { ERROR_TYPE } from './types.ts';
+
+export class ApiError extends Error {
+  public readonly status: number;
+  public readonly revision: string;
+  public readonly type?: ERROR_TYPE;
+  public readonly module: ERROR_MODULE;
+  public readonly code: ERROR_CODE;
+  public readonly message: string;
+  public readonly display: string;
+  public readonly stack?: string;
+  public readonly options: ApiErrorOptions;
+  public readonly displayMessageParams?: string[];
+
+  constructor({
+    status,
+    revision,
+    module,
+    code,
+    message,
+    type,
+    options: { shouldLog, shouldThrow, shouldTrace } = {
+      shouldLog: true,
+      shouldThrow: true,
+      shouldTrace: true,
+    },
+    displayMessageParams,
+  }: ErrorInfo) {
+    const safeMessage = message || getDisplayMessage(code, displayMessageParams || []) || '';
+    super(safeMessage);
+
+    this.status = status;
+    this.revision = revision || 'NO_REVISION';
+    this.module = module;
+    this.message = safeMessage;
+    this.display = getDisplayMessage(code, displayMessageParams || []);
+    this.code = code;
+    this.type = type || ERROR_TYPE.UNHANDLED_ERROR;
+    this.options = {
+      shouldLog: shouldLog || true,
+      shouldTrace: shouldTrace || true,
+      shouldThrow: shouldThrow || false,
+    };
+    this.displayMessageParams = displayMessageParams || [];
+
+    if (this.options.shouldTrace) Error.captureStackTrace(this);
+  }
+
+  public static fromErrorInfo(errorInfo: ErrorInfo): ApiError {
+    return new ApiError(errorInfo);
+  }
+
+  public toErrorInfo(): ErrorInfo {
+    return { ...this, identifier: this.identifier };
+  }
+
+  public get identifier(): string {
+    return `${this.revision}-${this.type || 'NO_TYPE'}-${this.module}-${this.code}`;
+  }
+
+  public get displayMessage(): string {
+    return getDisplayMessage(this.code, this.displayMessageParams || []);
+  }
+
+  public handle() {
+    const message = `[${this.identifier}]: ${this.message}`;
+
+    if (this.options.shouldLog) console.error(message, '\n', this.stack || '');
+    if (this.options.shouldThrow) throw Error(message, { cause: this.stack });
+
+    return this.toErrorInfo();
+  }
+}

package/src/errors/displayMessages.ts

@@ -0,0 +1,68 @@
+import { ERROR_CODE } from './types.ts';
+
+export const ERROR_DISPLAY_MESSAGES: Record<string, string> = {
+  [ERROR_CODE.INVALID_INPUT_PARAMETERS]: 'Invalid input parameters: {0}.',
+  [ERROR_CODE.UNKNOWN_PROVIDERS]: 'Unknown providers: {0}.',
+  [ERROR_CODE.CANNOT_FIND_INBOUND_ADDRESS]: 'Cannot find inbound address.',
+  [ERROR_CODE.NO_INBOUND_ADDRESSES]: 'No inbound addresses.',
+  [ERROR_CODE.CHAIN_HALTED_OR_UNSUPPORTED]: 'Chain {0} halted or unsupported.',
+  [ERROR_CODE.MISSING_INPUT_PARAMETER]: 'Missing input parameter: {0}.',
+  [ERROR_CODE.INVALID_TYPE_GENERIC]: 'Invalid type',
+  [ERROR_CODE.INVALID_NUMBER_STRING]: 'Invalid number string.',
+  [ERROR_CODE.INVALID_NUMBER]: 'Invalid number.',
+  [ERROR_CODE.INVALID_BOOLEAN]: 'Invalid boolean.',
+  [ERROR_CODE.INVALID_OBJECT]: 'Invalid object.',
+  [ERROR_CODE.INVALID_ARRAY]: 'Invalid array.',
+  [ERROR_CODE.SELL_AMOUNT_MUST_BE_POSITIVE_INTEGER]: 'Sell amount must be a positive integer.',
+  [ERROR_CODE.SELL_BUY_ASSETS_ARE_THE_SAME]: 'Sell and buy assets are the same.',
+  [ERROR_CODE.MISSING_SOURCE_ADDRESS_FOR_SYNTH]: 'Source address is required for synth quote.',
+  [ERROR_CODE.AFF_ADDRESS_AND_BPS_OR_NEITHER]:
+    'Must provide affiliateAddress and affiliateBasisPoints params, or neither.',
+  [ERROR_CODE.AFF_ADDRESS_TOO_LONG]: 'affiliateAddress too long: 3 characters max.',
+  [ERROR_CODE.AFF_BPS_INTEGER_0_100]: 'affiliateBasisPoints must be an integer between 0 and 100.',
+  [ERROR_CODE.SOURCE_ADDRESS_INVALID_FOR_SELL_CHAIN]: 'Source address {0} invalid for sell chain.',
+  [ERROR_CODE.DESTINATION_ADDRESS_INVALID_FOR_BUY_CHAIN]:
+    'Destination address {0} invalid for buy chain.',
+  [ERROR_CODE.PREFERRED_PROFVIDER_NOT_SUPPORTED]: 'Preferred provider not supported.',
+  [ERROR_CODE.DESTINATION_ADDRESS_SMART_CONTRACT]: 'Destination address is a smart contract.',
+  [ERROR_CODE.BUY_AMOUNT_MUST_BE_POSITIVE_INTEGER]: 'Buy amount must be a positive integer.',
+  [ERROR_CODE.INVALID_PROVIDER]: 'Invalid provider {0}.',
+  [ERROR_CODE.MISSING_CROSS_CHAIN_PROVIDER]: 'Missing cross-chain provider.',
+  [ERROR_CODE.MISSING_AVAX_PROVIDER]: 'Missing AVAX provider.',
+  [ERROR_CODE.MISSING_BSC_PROVIDER]: 'Missing BSC provider.',
+  [ERROR_CODE.MISSING_ETH_PROVIDER]: 'Missing ETH provider.',
+  [ERROR_CODE.MISSING_ARB_PROVIDER]: 'Missing ARB provider.',
+  [ERROR_CODE.INVALID_PROVIDER_FOR_SWAP_OUT]: 'Invalid provider for swap out.',
+  [ERROR_CODE.INVALID_CHAIN]: 'Invalid chain {0}.',
+  [ERROR_CODE.INVALID_ASSET]: 'Invalid asset {0}.',
+  [ERROR_CODE.UNSUPPORTED_CHAIN]: 'Unsupported chain {0}.',
+  [ERROR_CODE.UNSUPPORTED_ASSET]: 'Unsupported asset {0}.',
+  [ERROR_CODE.UNSUPPORTED_ASSET_FOR_SWAPOUT]: 'Unsupported asset {0} for swap out.',
+  [ERROR_CODE.THORNODE_QUOTE_GENERIC_ERROR]: 'ThorNode quote generic error.',
+  [ERROR_CODE.INVALID_SOURCE_ADDRESS]: 'Invalid source address {0}',
+  [ERROR_CODE.INVALID_DESTINATION_ADDRESS]: 'Invalid destination address {0}',
+  [ERROR_CODE.NOT_ENOUGH_SYNTH_BALANCE]:
+    "Source address doesn't have enough synth balance for this quote.",
+  [ERROR_CODE.SYNTH_MINTING_CAP_REACHED]: 'Synth minting cap reached.',
+  [ERROR_CODE.INVALID_QUOTE_MODE]: 'Invalid quote mode.',
+  [ERROR_CODE.NO_QUOTES]: 'No quotes to service this request.',
+  [ERROR_CODE.SERVICE_UNAVAILABLE_GENERIC]: 'Service unavailable.',
+  [ERROR_CODE.MISSING_GAS_DATA_GENERIC]: 'Missing gas data.',
+  [ERROR_CODE.MISSING_TOKEN_INFO_GENERIC]: 'Missing token info.',
+  [ERROR_CODE.CANT_FIND_TOKEN_LIST]: "Can't find tokenlist {0}.",
+  [ERROR_CODE.NO_PRICE]: 'No price for asset {0}.',
+  [ERROR_CODE.PRICE_IS_STALE]: 'Price is stale for asset {0}.',
+  [ERROR_CODE.ADDRESS_NOT_WHITELISTED]: 'Address {0} not whitelisted for airdrop.',
+  [ERROR_CODE.ADDRESS_ALREADY_CLAIMED]: 'Address {0} already claimed the airdrop.',
+};
+
+export const getDisplayMessage = (code: ERROR_CODE, displayMessageParams: string[]) => {
+  let displayMessage = ERROR_DISPLAY_MESSAGES[code];
+
+  for (let i = 0; i < displayMessageParams.length; i++) {
+    displayMessage = displayMessage.replace(`{${i}}`, displayMessageParams[i]);
+  }
+
+  if (displayMessageParams.length === 0) return displayMessage.replace('{0}', '');
+  else return displayMessage;
+};

package/src/errors/index.ts

@@ -0,0 +1,2 @@
+export * from './apiError.ts';
+export * from './types.ts';

package/src/errors/types.ts

@@ -0,0 +1,144 @@
+export enum ERROR_TYPE {
+  VALIDATION_ERROR = 'VALIDATION_ERROR',
+  REQUEST_PARAMETER_ERROR = 'REQUEST_PARAMETER_ERROR',
+  RESPONSE_PARSING_ERROR = 'RESPONSE_PARSING_ERROR',
+  UNSUPPORTED = 'UNSUPPORTED',
+  NOT_IMPLEMENTED = 'NOT_IMPLEMENTED',
+  INCOMPATIBLE_ASSETS_OPERATIONS = 'INCOMPATIBLE_ASSETS_OPERATIONS',
+  SERVICE_UNAVAILABLE = 'SERVICE_UNAVAILABLE',
+  DOWN_FOR_MAINTENANCE = 'DOWN_FOR_MAINTENANCE',
+  MISSING_INBOUND_INFO = 'MISSING_INBOUND_INFO',
+  QUOTE_FETCHING_ERROR = 'QUOTE_FETCHING_ERROR',
+  AIRDROP_ERROR = 'AIRDROP_ERROR',
+  UNHANDLED_ERROR = 'UNHANDLED_ERROR',
+}
+
+export enum ERROR_MODULE {
+  // Controllers
+  HEALTH_CONTROLLER = '1000',
+  LIQUIDITY_CONTROLLER = '1001',
+  PROVIDER_CONTROLLER = '1002',
+  QUOTE_CONTROLLER = '1003',
+  SWAP_CONTROLLER = '1004',
+  UTIL_CONTROLLER = '1005',
+  AIRDROP_CONTROLLER = '1006',
+  // Entities
+  PROVIDER = '2000',
+  ASSET = '2001',
+  TOKEN_LIST = '2002',
+  // Quote entities
+  QUOTE = '2100',
+  QUOTE_TXN_DETAILS = '2101',
+  // Providers
+  THORCHAIN_PROVIDER = '3000',
+  UNISWAPV2_ETH_PROVIDER = '3001',
+  UNISWAPV3_ETH_PROVIDER = '3002',
+  SUSHISWAP_ETH_PROVIDER = '3003',
+  PANCAKESWAP_BSC_PROVIDER = '3004',
+  PANCAKESWAP_ETH_PROVIDER = '3005',
+  ONEINCH_ETH_PROVIDER = '3006',
+  ONEINCH_BSC_PROVIDER = '3007',
+  ONEINCH_AVAX_PROVIDER = '3008',
+  ZEROX_ETH_PROVIDER = '3009',
+  WOOFI_AVAX_PROVIDER = '3010',
+  PANGOLIN_AVAX_PROVIDER = '3011',
+  TRADERJOE_AVAX_PROVIDER = '3012',
+  KYBER_ETH_PROVIDER = '3013',
+  KYBER_AVAX_PROVIDER = '3014',
+  WOOFI_BSC_PROVIDER = '3015',
+  STARGATE_PROVIDER = '3016',
+  // Utilities
+  PROVIDER_UTIL = '4000',
+  // Aggregator
+  TXN_DETAILS = '5000',
+  // AirDrop
+  AIRDROP_UTIL = '6000',
+}
+
+export enum ERROR_CODE {
+  // 10xx - Generic
+  INVALID_INPUT_PARAMETERS = '1000',
+  UNKNOWN_PROVIDERS = '1001',
+  CANNOT_FIND_INBOUND_ADDRESS = '1002',
+  NO_INBOUND_ADDRESSES = '1003',
+  CHAIN_HALTED_OR_UNSUPPORTED = '1004',
+  MISSING_INPUT_PARAMETER = '1005',
+  // 11xx - Type error
+  INVALID_TYPE_GENERIC = '1100',
+  INVALID_NUMBER_STRING = '1101',
+  INVALID_NUMBER = '1102',
+  INVALID_BOOLEAN = '1103',
+  INVALID_OBJECT = '1104',
+  INVALID_ARRAY = '1105',
+  // 20xx - Quote request parameters
+  SELL_AMOUNT_MUST_BE_POSITIVE_INTEGER = '2000',
+  SELL_BUY_ASSETS_ARE_THE_SAME = '2001',
+  MISSING_SOURCE_ADDRESS_FOR_SYNTH = '2002',
+  AFF_ADDRESS_AND_BPS_OR_NEITHER = '2003',
+  AFF_ADDRESS_TOO_LONG = '2004',
+  AFF_BPS_INTEGER_0_100 = '2005',
+  SOURCE_ADDRESS_INVALID_FOR_SELL_CHAIN = '2006',
+  DESTINATION_ADDRESS_INVALID_FOR_BUY_CHAIN = '2007',
+  PREFERRED_PROFVIDER_NOT_SUPPORTED = '2008',
+  DESTINATION_ADDRESS_SMART_CONTRACT = '2009',
+  BUY_AMOUNT_MUST_BE_POSITIVE_INTEGER = '2010',
+  SOURCE_ADDRESS_SMART_CONTRACT = '2011',
+  // 21xx - Quote request providers issue
+  INVALID_PROVIDER = '2100',
+  MISSING_CROSS_CHAIN_PROVIDER = '2101',
+  MISSING_AVAX_PROVIDER = '2102',
+  MISSING_BSC_PROVIDER = '2103',
+  MISSING_ETH_PROVIDER = '2104',
+  INVALID_PROVIDER_FOR_SWAP_OUT = '2105',
+  MISSING_ARB_PROVIDER = '2106',
+  // 22xx - Quote request assets issue
+  INVALID_CHAIN = '2200',
+  INVALID_ASSET = '2201',
+  INVALID_ASSET_IDENTIFIER = '2202',
+  UNSUPPORTED_CHAIN = '2204',
+  UNSUPPORTED_ASSET = '2203',
+  UNSUPPORTED_ASSET_FOR_SWAPOUT = '2205',
+  // 23xx - Invalid addresses
+  INVALID_SOURCE_ADDRESS = '2300',
+  INVALID_DESTINATION_ADDRESS = '2301',
+  // 30xx - Thorchain
+  THORNODE_QUOTE_GENERIC_ERROR = '3000',
+  NOT_ENOUGH_SYNTH_BALANCE = '3001',
+  SYNTH_MINTING_CAP_REACHED = '3002',
+  // 40xx - Code logic error (not the client's fault)
+  INVALID_QUOTE_MODE = '4000',
+  NO_QUOTES = '4001',
+  // 50xx - Service unavailable
+  SERVICE_UNAVAILABLE_GENERIC = '5000',
+  // 51xx - Missing gas data
+  MISSING_GAS_DATA_GENERIC = '5100',
+  // 52xx - Missing token info
+  MISSING_TOKEN_INFO_GENERIC = '5200',
+  CANT_FIND_TOKEN_LIST = '5201',
+  NO_PRICE = '5202',
+  PRICE_IS_STALE = '5203',
+  // 60xx - Airdrop
+  ADDRESS_NOT_WHITELISTED = '6000',
+  ADDRESS_ALREADY_CLAIMED = '6001',
+  // 90xx - Unhandled
+  TEMPORARY_ERROR = '9999', // use only when waiting for a PR to be merged
+}
+
+export type ErrorInfo = {
+  status: number;
+  revision: string;
+  type?: ERROR_TYPE;
+  module: ERROR_MODULE;
+  code: ERROR_CODE;
+  message?: string | undefined;
+  stack?: string;
+  identifier?: string;
+  options?: ApiErrorOptions;
+  displayMessageParams?: string[];
+};
+
+export type ApiErrorOptions = {
+  shouldLog?: boolean;
+  shouldTrace?: boolean;
+  shouldThrow?: boolean;
+};

package/src/index.ts

@@ -0,0 +1,8 @@
+export { erc20ABI } from './abis/erc20.ts';
+export { TCAvalancheDepositABI, TCBscDepositABI, TCEthereumVaultAbi } from './abis/tcEthVault.ts';
+export * from './commonTypes.ts';
+export * from './errors/index.ts';
+export * from './network.ts';
+export * from './thorchain.ts';
+export * from './transactions.ts';
+export * from './wallet.ts';

package/src/network.ts

@@ -0,0 +1,253 @@
+export enum Chain {
+  Arbitrum = 'ARB',
+  Avalanche = 'AVAX',
+  Binance = 'BNB',
+  BinanceSmartChain = 'BSC',
+  Bitcoin = 'BTC',
+  BitcoinCash = 'BCH',
+  Cosmos = 'GAIA',
+  Dogecoin = 'DOGE',
+  Ethereum = 'ETH',
+  Litecoin = 'LTC',
+  Maya = 'MAYA',
+  Optimism = 'OP',
+  Polygon = 'MATIC',
+  THORChain = 'THOR',
+}
+type ChainNameType = keyof typeof Chain;
+
+export enum ContractAddress {
+  ARB = '0x0000000000000000000000000000000000000000',
+  AVAX = '0x0000000000000000000000000000000000000000',
+  ETH = '0x0000000000000000000000000000000000000000',
+  BSC = '0x0000000000000000000000000000000000000000',
+  MATIC = '0x0000000000000000000000000000000000001010',
+  OP = '0x4200000000000000000000000000000000000042',
+}
+
+export enum NetworkId {
+  Ethereum = 60,
+  Binance = 714,
+  THORChain = 931,
+}
+
+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",
+  DOGE = "m/44'/3'/0'/0",
+  ETH = "m/44'/60'/0'/0",
+  GAIA = "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],
+  DOGE: [44, 3, 0, 0, 0],
+  ETH: [44, 60, 0, 0, 0],
+  GAIA: [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],
+};
+
+export enum BaseDecimal {
+  ARB = 18,
+  AVAX = 18,
+  BCH = 8,
+  BNB = 8,
+  BSC = 18,
+  BTC = 8,
+  DASH = 8,
+  DOGE = 8,
+  ETH = 18,
+  GAIA = 6,
+  KUJI = 6,
+  LTC = 8,
+  MATIC = 18,
+  MAYA = 10,
+  OP = 18,
+  THOR = 8,
+}
+
+export type EVMChain =
+  | Chain.Ethereum
+  | Chain.Avalanche
+  | Chain.BinanceSmartChain
+  | Chain.Arbitrum
+  | Chain.Optimism
+  | Chain.Polygon;
+
+export const EVMChainList: EVMChain[] = [
+  Chain.Ethereum,
+  Chain.Avalanche,
+  Chain.BinanceSmartChain,
+  Chain.Arbitrum,
+  Chain.Optimism,
+  Chain.Polygon,
+];
+
+export type UTXOChain = Chain.Bitcoin | Chain.BitcoinCash | Chain.Dogecoin | Chain.Litecoin;
+
+export const UTXOChainList: Chain[] = [
+  Chain.Bitcoin,
+  Chain.BitcoinCash,
+  Chain.Dogecoin,
+  Chain.Litecoin,
+];
+
+export type CosmosChain = Chain.Cosmos | Chain.THORChain | Chain.Binance;
+
+export const CosmosChainList: CosmosChain[] = [Chain.Cosmos, Chain.THORChain, Chain.Binance];
+
+export enum ChainId {
+  Arbitrum = '42161',
+  ArbitrumHex = '0xa4b1',
+  Avalanche = '43114',
+  AvalancheHex = '0xa86a',
+  Binance = 'Binance-Chain-Tigris',
+  BinanceSmartChain = '56',
+  BinanceSmartChainHex = '0x38',
+  Bitcoin = 'bitcoin',
+  BitcoinCash = 'bitcoincash',
+  Cosmos = 'cosmoshub-4',
+  Dogecoin = 'dogecoin',
+  Ethereum = '1',
+  EthereumHex = '0x1',
+  Litecoin = 'litecoin',
+  Maya = 'mayachain-mainnet-v1',
+  MayaStagenet = 'mayachain-stagenet-v1',
+  Optimism = '10',
+  OptimismHex = '0xa',
+  Polygon = '137',
+  PolygonHex = '0x89',
+  THORChain = 'thorchain-mainnet-v1',
+  THORChainStagenet = 'thorchain-stagenet-v2',
+}
+
+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',
+  Cosmos = 'https://node-router.thorswap.net/cosmos/rpc',
+  Dogecoin = 'https://node-router.thorswap.net/dogecoin',
+  Ethereum = 'https://node-router.thorswap.net/ethereum',
+  Litecoin = 'https://node-router.thorswap.net/litecoin',
+  Maya = 'https://tendermint.mayachain.info',
+  MayaStagenet = 'https://stagenet.tendermint.mayachain.info',
+  Optimism = 'https://mainnet.optimism.io',
+  Polygon = 'https://polygon-rpc.com',
+  THORChain = 'https://rpc.thorswap.net',
+  THORChainStagenet = 'https://stagenet-rpc.ninerealms.com',
+}
+
+export enum ApiUrl {
+  Cosmos = 'https://node-router.thorswap.net/cosmos/rest',
+  MayanodeMainnet = 'https://mayanode.mayachain.info',
+  MayanodeStagenet = 'https://stagenet.mayanode.mayachain.info',
+  ThornodeMainnet = 'https://thornode.thorswap.net',
+  ThornodeStagenet = 'https://stagenet-thornode.ninerealms.com',
+  ThorswapApi = 'https://api.thorswap.finance',
+  ThorswapStatic = 'https://static.thorswap.net',
+}
+
+const chains = Object.values(Chain) as Chain[];
+const chainNames = Object.keys(Chain) as ChainNameType[];
+
+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 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.Cosmos]: Chain.Cosmos,
+  [ChainId.Dogecoin]: Chain.Dogecoin,
+  [ChainId.EthereumHex]: Chain.Ethereum,
+  [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.PolygonHex]: Chain.Polygon,
+  [ChainId.Polygon]: Chain.Polygon,
+  [ChainId.THORChainStagenet]: Chain.THORChain,
+  [ChainId.THORChain]: Chain.THORChain,
+};
+
+export const ChainToExplorerUrl: Record<Chain, string> = {
+  [Chain.Arbitrum]: 'https://arbiscan.io',
+  [Chain.Avalanche]: 'https://snowtrace.io',
+  [Chain.BinanceSmartChain]: 'https://bscscan.com',
+  [Chain.Binance]: 'https://explorer.binance.org',
+  [Chain.BitcoinCash]: 'https://www.blockchain.com/bch',
+  [Chain.Bitcoin]: 'https://blockstream.info',
+  [Chain.Cosmos]: 'https://cosmos.bigdipper.live',
+  [Chain.Dogecoin]: 'https://blockchair.com/dogecoin',
+  [Chain.Ethereum]: 'https://etherscan.io',
+  [Chain.Litecoin]: 'https://ltc.bitaps.com',
+  [Chain.Maya]: 'https://www.mayascan.org',
+  [Chain.Optimism]: 'https://optimistic.etherscan.io',
+  [Chain.Polygon]: 'https://polygonscan.com',
+  [Chain.THORChain]: 'https://viewblock.io/thorchain',
+};