@ensofinance/checkout-widget 0.0.1

package/src/util/common.tsx

@@ -0,0 +1,324 @@
+import { useQuery } from "@tanstack/react-query";
+import { useAccount } from "wagmi";
+import { type Address, zeroAddress } from "viem";
+import {
+    CHAINS_ETHERSCAN,
+    CHAINS_NATIVE_TOKENS,
+    ETH_ADDRESS,
+    GECKO_CHAIN_NAMES,
+    SupportedChainId,
+} from "@/util/constants";
+import { useAppStore } from "@/store";
+
+export type Token = {
+    address: Address | string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    logoURI: string;
+    underlyingTokens?: Token[];
+    type?: string;
+    apy?: number;
+    tvl?: number;
+};
+
+export const compareCaseInsensitive = (a: string, b: string) => {
+    return !!(a && b && a?.toLowerCase() === b?.toLowerCase());
+};
+
+const MOCK_ARRAY = [];
+
+const getGeckoList = (chainId: SupportedChainId) =>
+    fetch(`https://tokens.coingecko.com/${GECKO_CHAIN_NAMES[chainId]}/all.json`)
+        .then((res) => res.json())
+        .then((data) => data?.tokens)
+        .then((tokens) => [CHAINS_NATIVE_TOKENS[chainId], ...tokens]);
+
+const getOogaboogaList: () => Promise<Token[]> = () =>
+    fetch(
+        "https://mainnet.internal.oogabooga.io/token-list/tokens?chainId=80094&client=SWAP",
+    )
+        .then((res) => res.json())
+        .then((data) =>
+            data.map((token) => ({
+                ...token,
+                logoURI: token.tokenURI,
+                address:
+                    token.address === zeroAddress
+                        ? ETH_ADDRESS
+                        : token.address.toLowerCase(),
+            })),
+        );
+
+const getRoosterList: () => Promise<Token[]> = () =>
+    fetch("https://api.rooster-protocol.xyz/api/tokens")
+        .then((res) => res.json())
+        .then(({ tokens }) => tokens);
+
+const getKatanaList: () => Promise<Token[]> = () =>
+    fetch(
+        "https://raw.githubusercontent.com/katana-network/tokenlist/refs/heads/main/tokenlist.json",
+    )
+        .then((res) => res.json())
+        .then(({ tokens }) => tokens);
+
+//
+// const getShadowList: (chainId: number) => Promise<Token[]> = () =>
+//   fetch(
+//     `https://raw.githubusercontent.com/Shadow-Exchange/shadow-assets/main/blockchains/sonic/tokenlist.json`,
+//   )
+//     .then((res) => res.json())
+//     .then((data) =>
+//       data.tokens[0]
+//         .map((token: any) => ({
+//           ...token,
+//           address: token.address?.toLowerCase(),
+//           logoURI: `https://raw.githubusercontent.com/Shadow-Exchange/shadow-assets/main/blockchains/sonic/assets/${token.address}/logo.png`,
+//         }))
+//         .filter(({ address }) => address),
+//     );
+
+const getOneInchTokenList = (chainId: number) =>
+    fetch("https://tokens.1inch.io/v1.2/" + chainId)
+        .then((res) => res.json())
+        .then((data) => Object.values(data) as Token[]);
+
+// .catch(() => tokenList[chainId]);
+
+const getChainSymbolSortPriority = (chainId: SupportedChainId) => {
+    const defaultPriority = {
+        [CHAINS_NATIVE_TOKENS[chainId].symbol]: 5,
+        USDC: 4,
+        DAI: 4,
+        USDT: 4,
+        WBTC: 4,
+        WETH: 3,
+        LINK: 3,
+        UNI: 3,
+        SUSHI: 3,
+        AAVE: 3,
+        USDCE: 2,
+    };
+    switch (chainId) {
+        default:
+            return defaultPriority;
+    }
+};
+
+const sonicAdditionalTokens = // TODO: remove after it comes in list for sonic
+    new Promise<Token[]>((resolve) =>
+        resolve([
+            {
+                address: "0x6047828dc181963ba44974801ff68e538da5eaf9",
+                name: "Tether USD",
+                symbol: "USDT",
+                decimals: 6,
+                logoURI:
+                    "https://assets.coingecko.com/coins/images/325/large/Tether.png",
+            },
+        ]),
+    );
+
+const plumeAdditionalTokens = // Additional tokens for Plume network
+    new Promise<Token[]>((resolve) =>
+        resolve([
+            {
+                address: ETH_ADDRESS, // Native token address
+                name: "Plume",
+                symbol: "PLUME",
+                decimals: 18,
+                logoURI:
+                    "https://assets.coingecko.com/coins/images/53623/standard/plume-token.png?1736896935",
+            },
+            {
+                address: "0x78adD880A697070c1e765Ac44D65323a0DcCE913",
+                name: "USD Coin.e",
+                symbol: "USDC.e",
+                decimals: 6,
+                logoURI:
+                    "https://assets.coingecko.com/coins/images/6319/large/USD_Coin_icon.png",
+            },
+            {
+                address: "0xEa237441c92CAe6FC17Caaf9a7acB3f953be4bd1",
+                name: "Wrapped Plume",
+                symbol: "wPlume",
+                decimals: 18,
+                logoURI:
+                    "https://assets.coingecko.com/coins/images/53623/standard/plume-token.png?1736896935",
+            },
+            {
+                address: "0xca59cA09E5602fAe8B629DeE83FfA819741f14be",
+                name: "Wrapped Ether",
+                symbol: "WETH",
+                decimals: 18,
+                logoURI:
+                    "https://assets.coingecko.com/coins/images/2518/large/weth.png",
+            },
+        ]),
+    );
+
+const getCurrentChainTokens = (chainId: SupportedChainId) => {
+    let getters: Promise<Token[] | undefined>[] = [];
+
+    switch (chainId) {
+        case SupportedChainId.BERACHAIN:
+            getters = [getOogaboogaList()];
+            break;
+        case SupportedChainId.SONIC:
+            getters = [getGeckoList(chainId), sonicAdditionalTokens];
+            break;
+        case SupportedChainId.PLUME:
+            getters = [plumeAdditionalTokens, getRoosterList()];
+            break;
+        default:
+            // priority for oneInch tokens
+            getters = [getGeckoList(chainId)];
+    }
+
+    return Promise.allSettled(getters).then((results) => {
+        const tokens = results
+            .filter(
+                (result): result is PromiseFulfilledResult<Token[]> =>
+                    result.status === "fulfilled",
+            )
+            .map((result) => result.value);
+
+        const tokenList = tokens[0];
+
+        if (tokens.length > 1) {
+            const addedToken = new Set<string>(
+                tokens[0]?.map((t) => t.address) ?? [],
+            );
+            const tokenList = tokens[0];
+
+            for (let i = 1; i < tokens.length; i++) {
+                const newTokens = tokens[i]?.filter(
+                    (token) => !addedToken.has(token.address),
+                );
+
+                if (newTokens) {
+                    tokenList.push(...newTokens);
+                    newTokens.forEach((t) => addedToken.add(t.address));
+                }
+            }
+        }
+
+        const priority = getChainSymbolSortPriority(chainId);
+
+        // sort by token symbol priority
+        const sortedTokenList = [...tokenList]
+            .sort((a, b) => {
+                return priority[b.symbol] ?? 0 - priority[a.symbol] ?? 0;
+            })
+            .map((token) => ({
+                ...token,
+                address: token.address.toLowerCase() as Address,
+            }));
+
+        return sortedTokenList;
+    });
+};
+
+export const useCurrentChainList = (priorityChainId?: SupportedChainId) => {
+    const chainId = usePriorityChainId(priorityChainId);
+
+    return useQuery<Token[] | undefined>({
+        queryKey: ["tokenList", chainId],
+        queryFn: () => getCurrentChainTokens(chainId),
+        enabled: !!chainId,
+    });
+};
+
+export const useOneInchTokenList = () => {
+    const chainId = usePriorityChainId();
+
+    return useQuery({
+        queryKey: ["oneInchTokenList", chainId],
+        queryFn: () => getOneInchTokenList(chainId),
+        enabled: !!chainId,
+    });
+};
+
+export const useTokenFromList = (
+    tokenAddress: Address | Address[],
+    priorityChainId?: SupportedChainId,
+) => {
+    const { data } = useCurrentChainList(priorityChainId);
+    const arrayData = Array.isArray(tokenAddress)
+        ? tokenAddress
+        : [tokenAddress];
+
+    return arrayData.map((address) =>
+        data?.find((token) => token.address == address),
+    );
+};
+
+const ALTERNATIVE_SYMBOLS = {
+    USDT: "USDT0",
+};
+
+export const useTokenFromListBySymbols = (
+    tokenSymbols: string[],
+    priorityChainId?: SupportedChainId,
+) => {
+    const { data } = useCurrentChainList(priorityChainId);
+    const arrayData = Array.isArray(tokenSymbols)
+        ? tokenSymbols
+        : [tokenSymbols];
+
+    return arrayData.map((symbol) =>
+        data?.find(
+            (token) => token.symbol == (ALTERNATIVE_SYMBOLS[symbol] ?? symbol),
+        ),
+    );
+};
+
+export const useOutChainId = () => {
+    const tokenOutChainId = useAppStore((state) => state.chainIdOut);
+    const chainId = usePriorityChainId();
+
+    return tokenOutChainId ?? chainId;
+};
+
+export const usePriorityChainId = (priorityChainId?: SupportedChainId) => {
+    const obligatedChainId = useAppStore((state) => state.chainIdIn);
+    const { chainId = 1 } = useAccount();
+
+    return priorityChainId ?? obligatedChainId ?? chainId;
+};
+
+export const useEtherscanUrl = (
+    address: string,
+    type: "/address" | "/tx" = "/tx",
+) => {
+    const chainId = usePriorityChainId();
+    const chainPrefix = CHAINS_ETHERSCAN[chainId];
+
+    if (address) return `${chainPrefix}${type}/${address}`;
+};
+
+export const capitalize = (s: string) => s.charAt(0).toUpperCase() + s.slice(1);
+
+export const getChainName = (chainId: SupportedChainId) => {
+    const geckoName = GECKO_CHAIN_NAMES[chainId];
+
+    return capitalize(geckoName).split("-")[0];
+};
+
+export const shortenAddress = (address: string) => {
+    return `${address.slice(0, 4)}...${address.slice(-4)}`;
+};
+
+export const getChainEtherscanUrl = ({
+    hash,
+    chainId,
+    type = "/tx",
+}: {
+    hash: string;
+    chainId: SupportedChainId;
+    type?: "/address" | "/tx";
+}) => {
+    const chainPrefix = CHAINS_ETHERSCAN[chainId];
+
+    if (hash) return `${chainPrefix}${type}/${hash}`;
+};

package/src/util/constants.tsx

@@ -0,0 +1,213 @@
+import { Token } from "@/util/common";
+
+export const ETH_ADDRESS = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+export const VITALIK_ADDRESS = "0xd8da6bf26964af9d7eed9e03e53415d37aa96045";
+export const DEFAULT_SLIPPAGE = 200;
+
+enum MESH_SYMBOLS {
+    ETH = "ETH",
+    USDC = "USDC",
+    USDT = "USDT",
+    WBTC = "WBTC",
+}
+export const MIN_AMOUNT = {
+    [MESH_SYMBOLS.ETH]: 0.02,
+    [MESH_SYMBOLS.USDC]: 20,
+    [MESH_SYMBOLS.USDT]: 20,
+    [MESH_SYMBOLS.WBTC]: 0.00000001,
+};
+
+export const ETH_TOKEN: Token = {
+    address: ETH_ADDRESS,
+    name: "Ethereum",
+    symbol: "ETH",
+    decimals: 18,
+    logoURI: "https://assets.coingecko.com/coins/images/279/large/ethereum.png",
+};
+export const BNB_TOKEN: Token = {
+    address: ETH_ADDRESS,
+    name: "Binance Coin",
+    symbol: "BNB",
+    decimals: 18,
+    logoURI:
+        "https://assets.coingecko.com/coins/images/825/large/binance-coin-logo.png",
+};
+export const AVAX_TOKEN: Token = {
+    address: ETH_ADDRESS,
+    name: "Avalanche",
+    symbol: "AVAX",
+    decimals: 18,
+    logoURI:
+        "https://assets.coingecko.com/coins/images/12559/large/coin-round-red.png",
+};
+export const MATIC_TOKEN: Token = {
+    address: ETH_ADDRESS,
+    name: "Polygon",
+    symbol: "MATIC",
+    decimals: 18,
+    logoURI:
+        "https://assets.coingecko.com/coins/images/4713/large/matic___polygon.jpg",
+};
+const BERA_TOKEN: Token = {
+    address: ETH_ADDRESS,
+    name: "BeraChain",
+    symbol: "BERA",
+    decimals: 18,
+    logoURI:
+        "https://assets.coingecko.com/coins/images/25235/large/BERA.png?1738822008",
+};
+const DAI_TOKEN: Token = {
+    address: ETH_ADDRESS,
+    name: "Gnosis XDAI",
+    symbol: "XDAI",
+    decimals: 18,
+    logoURI:
+        "https://assets.coingecko.com/coins/images/11062/large/Identity-Primary-DarkBG.png",
+};
+const SONIC_TOKEN: Token = {
+    address: ETH_ADDRESS,
+    name: "Sonic",
+    symbol: "S",
+    decimals: 18,
+    logoURI:
+        "https://assets.coingecko.com/coins/images/38108/standard/200x200_Sonic_Logo.png",
+};
+const PLUME_TOKEN: Token = {
+    address: ETH_ADDRESS,
+    name: "Plume",
+    symbol: "PLUME",
+    decimals: 18,
+    logoURI:
+        "https://assets.coingecko.com/coins/images/53623/standard/plume-token.png?1736896935",
+};
+const HYPERLIQUID_TOKEN: Token = {
+    address: ETH_ADDRESS,
+    name: "Hyperliquid",
+    symbol: "HYPE",
+    decimals: 18,
+    logoURI:
+        "https://assets.coingecko.com/asset_platforms/images/243/large/hyperliquid.png",
+};
+
+export const MOCK_IMAGE_URL =
+    "https://assets.coingecko.com/coins/images/12504/small/uniswap-uni.png";
+
+export enum SupportedChainId {
+    MAINNET = 1,
+    ARBITRUM_ONE = 42161,
+    OPTIMISM = 10,
+    POLYGON = 137,
+    BSC = 56,
+    // BOBA = 288,
+    BASE = 8453,
+    // BLAST = 81457,
+    // SCROLL = 534352,
+    LINEA = 59144,
+    ZKSYNC = 324,
+    GNOSIS = 100,
+    AVALANCHE = 43114,
+    BERACHAIN = 80094,
+    SONIC = 146,
+    UNICHAIN = 130,
+    INK = 57073,
+    SONEIUM = 1868,
+    PLUME = 98866,
+    HYPERLIQUID = 999,
+    KATANA = 747474,
+    // ARBITRUM_RINKEBY = 421611,
+    // OPTIMISM_GOERLI = 420,w
+    // GOERLI = 5,
+    // POLYGON_MUMBAI = 80001,
+    // CELO = 42220,
+    // CELO_ALFAJORES = 44787,
+}
+
+export const STARGATE_CHAIN_NAMES: { [key in SupportedChainId]: string } = {
+    [SupportedChainId.MAINNET]: "ethereum",
+    [SupportedChainId.BASE]: "base",
+    [SupportedChainId.POLYGON]: "polygon",
+    [SupportedChainId.BSC]: "bsc",
+    [SupportedChainId.LINEA]: "linea",
+    [SupportedChainId.ZKSYNC]: "zksync",
+    [SupportedChainId.GNOSIS]: "gnosis",
+    [SupportedChainId.AVALANCHE]: "avalanche",
+    [SupportedChainId.BERACHAIN]: "bera",
+    [SupportedChainId.SONIC]: "sonic",
+    [SupportedChainId.ARBITRUM_ONE]: "arbitrum",
+    [SupportedChainId.OPTIMISM]: "optimism",
+    [SupportedChainId.UNICHAIN]: "unichain",
+    [SupportedChainId.INK]: "ink",
+    [SupportedChainId.SONEIUM]: "soneium",
+    [SupportedChainId.PLUME]: "plumephoenix",
+    [SupportedChainId.HYPERLIQUID]: "hyperliquid",
+    [SupportedChainId.KATANA]: "katana",
+};
+
+export const GECKO_CHAIN_NAMES: { [key in SupportedChainId]: string } = {
+    [SupportedChainId.MAINNET]: "ethereum",
+    [SupportedChainId.ARBITRUM_ONE]: "arbitrum-one",
+    [SupportedChainId.OPTIMISM]: "optimistic-ethereum",
+    [SupportedChainId.POLYGON]: "polygon-pos",
+    // [SupportedChainId.BOBA]: "boba",
+    [SupportedChainId.BASE]: "base",
+    [SupportedChainId.BSC]: "binance-smart-chain",
+    // [SupportedChainId.BLAST]: "blast",
+    // [SupportedChainId.SCROLL]: "scroll",
+    [SupportedChainId.LINEA]: "linea",
+    [SupportedChainId.ZKSYNC]: "zksync",
+    [SupportedChainId.GNOSIS]: "xdai",
+    [SupportedChainId.AVALANCHE]: "avalanche",
+    [SupportedChainId.BERACHAIN]: "berachain",
+    [SupportedChainId.SONIC]: "sonic",
+    [SupportedChainId.UNICHAIN]: "unichain",
+    [SupportedChainId.INK]: "ink",
+    [SupportedChainId.SONEIUM]: "soneium",
+    [SupportedChainId.PLUME]: "plume",
+    [SupportedChainId.HYPERLIQUID]: "hyperevm",
+    [SupportedChainId.KATANA]: "katana",
+};
+
+export const CHAINS_NATIVE_TOKENS: Record<SupportedChainId, Token> = {
+    [SupportedChainId.MAINNET]: ETH_TOKEN,
+    [SupportedChainId.ARBITRUM_ONE]: ETH_TOKEN,
+    [SupportedChainId.OPTIMISM]: ETH_TOKEN,
+    [SupportedChainId.BASE]: ETH_TOKEN,
+    [SupportedChainId.LINEA]: ETH_TOKEN,
+    [SupportedChainId.ZKSYNC]: ETH_TOKEN,
+    [SupportedChainId.SONEIUM]: ETH_TOKEN,
+    [SupportedChainId.UNICHAIN]: ETH_TOKEN,
+    [SupportedChainId.INK]: ETH_TOKEN,
+    [SupportedChainId.BSC]: BNB_TOKEN,
+    [SupportedChainId.AVALANCHE]: AVAX_TOKEN,
+    [SupportedChainId.POLYGON]: MATIC_TOKEN,
+    [SupportedChainId.BERACHAIN]: BERA_TOKEN,
+    [SupportedChainId.GNOSIS]: DAI_TOKEN,
+    [SupportedChainId.SONIC]: SONIC_TOKEN,
+    [SupportedChainId.PLUME]: PLUME_TOKEN,
+    [SupportedChainId.HYPERLIQUID]: HYPERLIQUID_TOKEN,
+    [SupportedChainId.KATANA]: ETH_TOKEN,
+};
+
+export const CHAINS_ETHERSCAN: Record<SupportedChainId, string> = {
+    [SupportedChainId.OPTIMISM]: "https://optimistic.etherscan.io",
+    [SupportedChainId.MAINNET]: "https://etherscan.io",
+    [SupportedChainId.ARBITRUM_ONE]: "https://arbiscan.io",
+    [SupportedChainId.POLYGON]: "https://polygonscan.com",
+    [SupportedChainId.BSC]: "https://bscscan.com",
+    // [SupportedChainId.BOBA]: "https://bobascan.com",
+    [SupportedChainId.BASE]: "https://basescan.org",
+    // [SupportedChainId.BLAST]: "https://blastscan.io",
+    // [SupportedChainId.SCROLL]: "https://scrollscan.com",
+    [SupportedChainId.LINEA]: "https://lineascan.build",
+    [SupportedChainId.ZKSYNC]: "https://explorer.zksync.io/",
+    [SupportedChainId.GNOSIS]: "https://gnosisscan.io/",
+    [SupportedChainId.AVALANCHE]: "https://cchain.explorer.avax.network",
+    [SupportedChainId.BERACHAIN]: "https://berascan.com",
+    [SupportedChainId.SONIC]: "https://sonicscan.io",
+    [SupportedChainId.UNICHAIN]: "https://uniscan.xyz",
+    [SupportedChainId.INK]: "https://explorer.inkonchain.com",
+    [SupportedChainId.SONEIUM]: "https://soneium.blockscout.com/",
+    [SupportedChainId.PLUME]: "https://explorer.plume.org/",
+    [SupportedChainId.HYPERLIQUID]: "https://www.hyperscan.com/",
+    [SupportedChainId.KATANA]: "https://explorer-katana.t.conduit.xyz/",
+};