@swapkit/helpers 1.0.0-rc.11 → 1.0.0-rc.110

package/src/helpers/memo.ts

@@ -1,7 +1,7 @@
-import type { Chain } from '@swapkit/types';
-import { MemoType } from '@swapkit/types';
+import { Chain } from "../types/chains";
+import { MemoType } from "../types/sdk";
 
-export type ThornameRegisterParam = {
+export type NameRegisterParam = {
   name: string;
   chain: string;
   address: string;
@@ -10,25 +10,14 @@ export type ThornameRegisterParam = {
   expiryBlock?: string;
 };
 
-const getShortenedSymbol = ({
-  symbol,
-  ticker,
-  chain,
-}: {
-  ticker: string;
-  symbol: string;
-  chain: string | Chain;
-}) => (chain === 'ETH' && ticker !== 'ETH' ? `${ticker}-${symbol.slice(-3)}` : symbol);
-
-type WithAddress<T = {}> = T & { address: string };
-type WithChain<T = {}> = T & { chain: Chain };
+type WithChain<T extends {}> = T & { chain: Chain };
 
 export type MemoOptions<T extends MemoType> = {
-  [MemoType.BOND]: WithAddress;
-  [MemoType.LEAVE]: WithAddress;
-  [MemoType.CLOSE_LOAN]: WithAddress<{ asset: string; minAmount?: string }>;
-  [MemoType.OPEN_LOAN]: WithAddress<{ asset: string; minAmount?: string }>;
-  [MemoType.UNBOND]: WithAddress<{ unbondAmount: number }>;
+  [MemoType.BOND]: { address: string };
+  [MemoType.LEAVE]: { address: string };
+  [MemoType.CLOSE_LOAN]: { address: string; asset: string; minAmount?: string };
+  [MemoType.OPEN_LOAN]: { address: string; asset: string; minAmount?: string };
+  [MemoType.UNBOND]: { address: string; unbondAmount: number };
   [MemoType.DEPOSIT]: WithChain<{ symbol: string; address?: string; singleSide?: boolean }>;
   [MemoType.WITHDRAW]: WithChain<{
     ticker: string;
@@ -37,7 +26,7 @@ export type MemoOptions<T extends MemoType> = {
     targetAssetString?: string;
     singleSide?: boolean;
   }>;
-  [MemoType.THORNAME_REGISTER]: Omit<ThornameRegisterParam, 'preferredAsset' | 'expiryBlock'>;
+  [MemoType.NAME_REGISTER]: Omit<NameRegisterParam, "preferredAsset" | "expiryBlock">;
 }[T];
 
 export const getMemoFor = <T extends MemoType>(memoType: T, options: MemoOptions<T>) => {
@@ -50,29 +39,43 @@ export const getMemoFor = <T extends MemoType>(memoType: T, options: MemoOptions
 
     case MemoType.UNBOND: {
       const { address, unbondAmount } = options as MemoOptions<MemoType.UNBOND>;
-      return `${memoType}:${address}:${unbondAmount * 10 ** 8}`;
+      return `${memoType}:${address}:${unbondAmount}`;
     }
 
-    case MemoType.THORNAME_REGISTER: {
-      const { name, chain, address, owner } = options as MemoOptions<MemoType.THORNAME_REGISTER>;
-      return `${memoType}:${name}:${chain}:${address}${owner ? `:${owner}` : ''}`;
+    case MemoType.NAME_REGISTER: {
+      const { name, chain, address, owner } = options as MemoOptions<MemoType.NAME_REGISTER>;
+      return `${memoType}:${name}:${chain}:${address}${owner ? `:${owner}` : ""}`;
     }
 
     case MemoType.DEPOSIT: {
       const { chain, symbol, address, singleSide } = options as MemoOptions<MemoType.DEPOSIT>;
 
+      const getPoolIdentifier = (chain: Chain, symbol: string): string => {
+        switch (chain) {
+          case Chain.Litecoin:
+            return "l";
+          case Chain.Dogecoin:
+            return "d";
+          case Chain.BitcoinCash:
+            return "c";
+          default:
+            return `${chain}.${symbol}`;
+        }
+      };
+
       return singleSide
-        ? `${memoType}:${chain}/${symbol}::t:0`
-        : `${memoType}:${chain}.${symbol}:${address || ''}:t:0`;
+        ? `${memoType}:${chain}/${symbol}`
+        : `${memoType}:${getPoolIdentifier(chain, symbol)}:${address || ""}`;
     }
 
     case MemoType.WITHDRAW: {
       const { chain, ticker, symbol, basisPoints, targetAssetString, singleSide } =
         options as MemoOptions<MemoType.WITHDRAW>;
 
-      const target = !singleSide && targetAssetString ? `:${targetAssetString}` : '';
-      const shortenedSymbol = getShortenedSymbol({ chain, symbol, ticker });
-      const assetDivider = singleSide ? '/' : '.';
+      const shortenedSymbol =
+        chain === "ETH" && ticker !== "ETH" ? `${ticker}-${symbol.slice(-3)}` : symbol;
+      const target = !singleSide && targetAssetString ? `:${targetAssetString}` : "";
+      const assetDivider = singleSide ? "/" : ".";
 
       return `${memoType}:${chain}${assetDivider}${shortenedSymbol}:${basisPoints}${target}`;
     }
@@ -85,6 +88,6 @@ export const getMemoFor = <T extends MemoType>(memoType: T, options: MemoOptions
     }
 
     default:
-      return '';
+      return "";
   }
 };

package/src/helpers/others.ts

@@ -1,20 +1,54 @@
+import { type ErrorKeys, SwapKitError } from "../modules/swapKitError";
+import { Chain } from "../types";
+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 function wrapWithThrow<T>(fn: () => T, errorKey?: ErrorKeys) {
+  try {
+    return fn();
+  } catch (error) {
+    if (errorKey) {
+      throw new SwapKitError(errorKey, error);
+    }
+
+    return console.error(error);
+  }
+}
+
+export const getChainIdentifier = (chain: Chain) => {
+  switch (chain) {
+    case Chain.THORChain:
+      return `${chain}.RUNE`;
+
+    case Chain.Cosmos:
+      return `${chain}.ATOM`;
 
-export const derivationPathToString = ([network, chainId, account, change, index]: number[]) => {
-  const shortPath = typeof index !== 'number';
+    case Chain.BinanceSmartChain:
+      return `${chain}`;
 
-  return `${network}'/${chainId}'/${account}'/${change}${shortPath ? '' : `/${index}`}`;
+    default:
+      return `${chain}.${chain}`;
+  }
 };

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,200 @@
+import type { BrowserProvider } from "ethers";
+import {
+  ChainId,
+  type EIP6963AnnounceProviderEvent,
+  type EIP6963Provider,
+  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",
+  "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);
+};
+
+export 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 function getEIP6963Wallets() {
+  const providers: EIP6963Provider[] = [];
+
+  function onAnnouncement(event: EIP6963AnnounceProviderEvent) {
+    if (providers.map((p) => p.info.uuid).includes(event.detail.info.uuid)) return;
+    providers.push(event.detail);
+  }
+
+  window.addEventListener("eip6963:announceProvider", onAnnouncement);
+  window.dispatchEvent(new Event("eip6963:requestProvider"));
+
+  function removeEIP6963EventListener() {
+    window.removeEventListener("eip6963:announceProvider", onAnnouncement);
+  }
+
+  return { providers, removeEIP6963EventListener };
+}
+
+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";