@swapkit/helpers 1.0.0-rc.9 → 1.0.0-rc.91

package/src/helpers/others.ts

@@ -1,20 +1,37 @@
+import { type ErrorKeys, SwapKitError } from "../modules/swapKitError";
+import type { DerivationPathArray } from "../types/derivationPath";
+
 // 10 rune for register, 1 rune per year
 // MINIMUM_REGISTRATION_FEE = 11
-export const getTHORNameCost = (year: number) => {
-  if (year < 0) throw new Error('Invalid number of year');
-  return 10 + year;
-};
+export function getTHORNameCost(numberOfYears: number) {
+  if (numberOfYears < 0) throw new Error("Invalid number of years");
+  return 10 + numberOfYears;
+}
 
-export const validateTHORName = (name: string) => {
-  if (name.length > 30) return false;
+// 10 CACAO for register
+// 1.0512 CACAO per year
+export function getMAYANameCost(numberOfYears: number) {
+  if (numberOfYears < 0) throw new Error("Invalid number of year");
+  // round to max 10 decimals
+  return Math.round((10 + numberOfYears * 1.0512) * 1e10) / 1e10;
+}
 
-  const regex = /^[a-zA-Z0-9+_-]+$/g;
+export function derivationPathToString([network, chainId, account, change, index]:
+  | [number, number, number, number, number | undefined]
+  | DerivationPathArray) {
+  const shortPath = typeof index !== "number";
 
-  return !!name.match(regex);
-};
+  return `m/${network}'/${chainId}'/${account}'/${change}${shortPath ? "" : `/${index}`}`;
+}
 
-export const derivationPathToString = ([network, chainId, account, change, index]: number[]) => {
-  const shortPath = typeof index !== 'number';
+export function wrapWithThrow<T>(fn: () => T, errorKey?: ErrorKeys) {
+  try {
+    return fn();
+  } catch (error) {
+    if (errorKey) {
+      throw new SwapKitError(errorKey, error);
+    }
 
-  return `${network}'/${chainId}'/${account}'/${change}${shortPath ? '' : `/${index}`}`;
-};
+    return console.error(error);
+  }
+}

package/src/helpers/validators.ts

@@ -1,17 +1,26 @@
-import { Chain } from '@swapkit/types';
+import { Chain } from "../types/chains";
 
-const supportedChains = Object.values(Chain);
+// Backward compatibility
+const supportedChains = [...Object.values(Chain), "TERRA"];
 
-export const validateIdentifier = (identifier: string = '') => {
+export function validateIdentifier(identifier = "") {
   const uppercasedIdentifier = identifier.toUpperCase();
 
-  const [chain] = uppercasedIdentifier.split('.') as [Chain, string];
+  const [chain] = uppercasedIdentifier.split(".") as [Chain, string];
   if (supportedChains.includes(chain)) return true;
 
-  const [synthChain] = uppercasedIdentifier.split('/') as [Chain, string];
+  const [synthChain] = uppercasedIdentifier.split("/") as [Chain, string];
   if (supportedChains.includes(synthChain)) return true;
 
   throw new Error(
     `Invalid identifier: ${identifier}. Expected format: <Chain>.<Ticker> or <Chain>.<Ticker>-<ContractAddress>`,
   );
-};
+}
+
+export function validateTNS(name: string) {
+  if (name.length > 30) return false;
+
+  const regex = /^[a-zA-Z0-9+_-]+$/g;
+
+  return !!name.match(regex);
+}

package/src/helpers/web3wallets.ts

@@ -0,0 +1,178 @@
+import type { BrowserProvider } from "ethers";
+import { ChainId, WalletOption } from "../types";
+
+export type EthereumWindowProvider = BrowserProvider & {
+  __XDEFI?: boolean;
+  isBraveWallet?: boolean;
+  isCoinbaseWallet?: boolean;
+  isMetaMask?: boolean;
+  isOkxWallet?: boolean;
+  isTrust?: boolean;
+  on: (event: string, callback?: () => void) => void;
+  overrideIsMetaMask?: boolean;
+  request: <T = unknown>(args: { method: string; params?: unknown[] }) => Promise<T>;
+  selectedProvider?: EthereumWindowProvider;
+};
+
+declare const window: {
+  ethereum: EthereumWindowProvider;
+  trustwallet: EthereumWindowProvider;
+  coinbaseWalletExtension: EthereumWindowProvider;
+  braveSolana: Todo;
+} & Window;
+
+// declare global {
+//   interface Window {
+//     ethereum: EthereumWindowProvider;
+//     trustwallet: EthereumWindowProvider;
+//     coinbaseWalletExtension: EthereumWindowProvider;
+//     braveSolana: Todo;
+//   }
+// }
+
+type NetworkParams = {
+  chainId: ChainId;
+  chainName: string;
+  nativeCurrency: {
+    name: string;
+    symbol: string;
+    decimals: number;
+  };
+  rpcUrls: string[];
+  blockExplorerUrls: string[];
+};
+
+type ProviderRequestParams = {
+  provider?: BrowserProvider;
+  params?: Todo;
+  method:
+    | "wallet_addEthereumChain"
+    | "wallet_switchEthereumChain"
+    | "eth_requestAccounts"
+    | "eth_sendTransaction"
+    | "eth_signTransaction";
+};
+
+const methodsToWrap = [
+  "approve",
+  "approvedAmount",
+  "call",
+  "sendTransaction",
+  "transfer",
+  "getBalance",
+  "isApproved",
+  "approvedAmount",
+  "EIP1193SendTransaction",
+  "getFeeData",
+  "broadcastTransaction",
+  "estimateCall",
+  "estimateGasLimit",
+  "estimateGasPrices",
+  "createContractTxObject",
+];
+
+export const wrapMethodWithNetworkSwitch = <T extends (...args: Todo[]) => Todo>(
+  func: T,
+  provider: BrowserProvider,
+  chainId: ChainId,
+) =>
+  (async (...args: Todo[]) => {
+    try {
+      await switchEVMWalletNetwork(provider, chainId);
+    } catch (error) {
+      throw new Error(`Failed to switch network: ${error}`);
+    }
+    return func(...args);
+  }) as unknown as T;
+
+const providerRequest = ({ provider, params, method }: ProviderRequestParams) => {
+  if (!provider?.send) throw new Error("Provider not found");
+
+  const providerParams = params ? (Array.isArray(params) ? params : [params]) : [];
+  return provider.send(method, providerParams);
+};
+
+export const prepareNetworkSwitch = <T extends { [key: string]: (...args: Todo[]) => Todo }>({
+  toolbox,
+  chainId,
+  provider = window.ethereum,
+}: {
+  toolbox: T;
+  chainId: ChainId;
+  provider?: BrowserProvider;
+}) => {
+  const wrappedMethods = methodsToWrap.reduce((object, methodName) => {
+    if (!toolbox[methodName]) return object;
+    const method = toolbox[methodName];
+
+    if (typeof method !== "function") return object;
+
+    return {
+      // biome-ignore lint/performance/noAccumulatingSpread: This is a valid use case
+      ...object,
+      [methodName]: wrapMethodWithNetworkSwitch<typeof method>(method, provider, chainId),
+    };
+  }, {});
+
+  return { ...toolbox, ...wrappedMethods };
+};
+
+export const addEVMWalletNetwork = (provider: BrowserProvider, networkParams: NetworkParams) =>
+  providerRequest({ provider, method: "wallet_addEthereumChain", params: [networkParams] });
+
+export const switchEVMWalletNetwork = (provider: BrowserProvider, chainId = ChainId.EthereumHex) =>
+  providerRequest({ provider, method: "wallet_switchEthereumChain", params: [{ chainId }] });
+
+export const addAccountsChangedCallback = (callback: () => void) => {
+  window.ethereum?.on("accountsChanged", () => callback());
+  // @ts-expect-error that should be implemented in xdefi and hooked up via swapkit core
+  window.xfi?.ethereum.on("accountsChanged", () => callback());
+};
+
+export const getETHDefaultWallet = () => {
+  const { isTrust, isBraveWallet, __XDEFI, overrideIsMetaMask, selectedProvider } =
+    window?.ethereum || {};
+  if (isTrust) return WalletOption.TRUSTWALLET_WEB;
+  if (isBraveWallet) return WalletOption.BRAVE;
+  if (overrideIsMetaMask && selectedProvider?.isCoinbaseWallet) return WalletOption.COINBASE_WEB;
+  if (__XDEFI) WalletOption.XDEFI;
+  return WalletOption.METAMASK;
+};
+
+export const isDetected = (walletOption: WalletOption) => {
+  return listWeb3EVMWallets().includes(walletOption);
+};
+
+const listWeb3EVMWallets = () => {
+  const metamaskEnabled = window?.ethereum && !window.ethereum?.isBraveWallet;
+  // @ts-ignore that should be implemented in xdefi and hooked up via swapkit core
+  const xdefiEnabled = window?.xfi || window?.ethereum?.__XDEFI;
+  const braveEnabled = window?.ethereum?.isBraveWallet;
+  const trustEnabled = window?.ethereum?.isTrust || window?.trustwallet;
+  const coinbaseEnabled =
+    (window?.ethereum?.overrideIsMetaMask &&
+      window?.ethereum?.selectedProvider?.isCoinbaseWallet) ||
+    window?.coinbaseWalletExtension;
+
+  const wallets = [];
+  if (metamaskEnabled) wallets.push(WalletOption.METAMASK);
+  if (xdefiEnabled) wallets.push(WalletOption.XDEFI);
+  if (braveEnabled) wallets.push(WalletOption.BRAVE);
+  if (trustEnabled) wallets.push(WalletOption.TRUSTWALLET_WEB);
+  if (coinbaseEnabled) wallets.push(WalletOption.COINBASE_WEB);
+  if (okxMobileEnabled()) wallets.push(WalletOption.OKX_MOBILE);
+
+  return wallets;
+};
+
+export const okxMobileEnabled = () => {
+  const ua = navigator.userAgent;
+  const isIOS = /iphone|ipad|ipod|ios/i.test(ua);
+  const isAndroid = /android|XiaoMi|MiuiBrowser/i.test(ua);
+  const isMobile = isIOS || isAndroid;
+  const isOKApp = /OKApp/i.test(ua);
+
+  return isMobile && isOKApp;
+};
+
+export const isWeb3Detected = () => typeof window.ethereum !== "undefined";

package/src/index.ts

@@ -1,16 +1,21 @@
+export * from "./types/index.ts";
+
 /**
  * Helpers
  */
-export * from './helpers/asset.ts';
-export * from './helpers/liquidity.ts';
-export * from './helpers/memo.ts';
-export * from './helpers/others.ts';
-export * from './helpers/request.ts';
+export * from "./helpers/asset.ts";
+export * from "./helpers/derivationPath.ts";
+export * from "./helpers/liquidity.ts";
+export * from "./helpers/memo.ts";
+export * from "./helpers/others.ts";
+export * from "./helpers/validators.ts";
+export * from "./helpers/web3wallets.ts";
 
 /**
  * Modules
  */
-export * from './modules/assetValue.ts';
-export * from './modules/bigIntArithmetics.ts';
-export * from './modules/swapKitError.ts';
-export * from './modules/swapKitNumber.ts';
+export * from "./modules/assetValue.ts";
+export * from "./modules/bigIntArithmetics.ts";
+export * from "./modules/requestClient.ts";
+export * from "./modules/swapKitError.ts";
+export * from "./modules/swapKitNumber.ts";