@ensofinance/checkout-widget 0.0.1

package/src/enso-api/api.ts

@@ -0,0 +1,173 @@
+import { useAccount } from "wagmi";
+import {
+    useRouterControllerPostRouteShortcutTransaction,
+    useRouterControllerRouteShortcutTransaction,
+    useTokensControllerTokens,
+    useWalletControllerCreateApproveTransaction,
+    useWalletControllerWalletBalances,
+} from "@/enso-api";
+import { useMemo } from "react";
+import { usePricesControllerGetPrice } from "@/enso-api";
+import { Token } from "@/util/common";
+import { useAppStore } from "@/store";
+import { Address } from "viem";
+import { formatNumber, normalizeValue } from "@/util";
+import { VITALIK_ADDRESS } from "@/util/constants";
+import { RouterControllerRouteShortcutTransactionParams } from "./model";
+
+export const useWalletBalance = () => {
+    const { address } = useAccount();
+    const ensoApiToken = useAppStore((state) => state.ensoApiToken);
+
+    const { data, isLoading } = useWalletControllerWalletBalances(
+        {
+            eoaAddress: address,
+            // @ts-ignore
+            chainId: "all",
+            // chainId: 8453,
+        },
+        {
+            query: {
+                enabled: !!address && !!ensoApiToken,
+            },
+        },
+    );
+
+    const { holdingsList, total } = useMemo(() => {
+        if (!data?.length) return { holdingsList: [], total: 0 };
+
+        const holdingsList = data
+            ?.map((balanace) => ({
+                ...balanace,
+                total:
+                    (+balanace.amount / 10 ** balanace.decimals) *
+                    +balanace.price,
+            }))
+            .filter((balance) => balance.total > 1 && balance.total < 10000)
+            .sort((a, b) => b.total - a.total);
+
+        const total = holdingsList?.reduce((acc, { total }) => acc + total, 0);
+
+        return { holdingsList, total };
+    }, [data]);
+
+    return { holdingsList, total, isLoading };
+};
+
+const mapTokenData = (tokenData: any): Token => ({
+    ...tokenData,
+    logoURI: tokenData?.logosUri?.[0],
+    underlyingTokens: tokenData?.underlyingTokens?.map(mapTokenData),
+});
+
+//immutable array
+const MOCK_ARRAY = [];
+
+export const useEnsoToken = (token: string, chainId: number) => {
+    const { data, isLoading } = useTokensControllerTokens(
+        { address: [token], chainId, includeMetadata: true },
+        { query: { enabled: !!token && !!chainId } },
+    );
+
+    return {
+        data: data?.data?.length ? data?.data?.map(mapTokenData) : MOCK_ARRAY,
+        isLoading,
+    };
+};
+
+export const useEnsoPrice = (chainId: number, token: string) => {
+    const { data, isLoading } = usePricesControllerGetPrice(chainId, token);
+
+    return { data: data?.price, isLoading };
+};
+
+export const useEnsoData = ({
+    chainId,
+    outChainId,
+    fromAddress,
+    receiver,
+    spender,
+    amountIn,
+    tokenIn,
+    tokenOut,
+    slippage,
+    referralCode,
+    routingStrategy = "router",
+}: {
+    chainId: number;
+    outChainId: number;
+    fromAddress: string;
+    receiver: string;
+    spender: string;
+    amountIn: string;
+    tokenIn: string;
+    tokenOut: string;
+    slippage: number;
+    referralCode?: string;
+    routingStrategy?: "router" | "checkout";
+}) => {
+    const routerParams: RouterControllerRouteShortcutTransactionParams = {
+        referralCode,
+        amountIn: [amountIn],
+        tokenIn: [tokenIn],
+        tokenOut: [tokenOut],
+        slippage: slippage.toString(),
+        fromAddress,
+        receiver,
+        spender,
+        // @ts-ignore
+        routingStrategy,
+        chainId,
+    };
+
+    let isCrosschain = outChainId !== chainId;
+
+    if (isCrosschain) {
+        routerParams.destinationChainId = outChainId;
+    }
+
+    const {
+        data: [tokenToData],
+    } = useEnsoToken(tokenOut, outChainId);
+    const {
+        data: [tokenFromData],
+    } = useEnsoToken(tokenIn, chainId);
+
+    const swapTitle = `Purchase ${formatNumber(
+        normalizeValue(amountIn, tokenFromData?.decimals),
+    )} ${tokenFromData?.symbol} of ${tokenToData?.symbol}`;
+
+    const routerData = useRouterControllerRouteShortcutTransaction(
+        routerParams,
+        {
+            query: {
+                retry: 2,
+                enabled:
+                    !!routerParams.amountIn && !!tokenFromData && !!tokenToData,
+            },
+        },
+    );
+
+    return { ...routerData, title: swapTitle };
+};
+
+export const useApproveData = ({
+    address,
+    token,
+    chainId,
+    amount,
+}: {
+    address: string;
+    token: string;
+    chainId: number;
+    amount: string;
+}) => {
+    const res = useWalletControllerCreateApproveTransaction({
+        fromAddress: address,
+        tokenAddress: token,
+        chainId,
+        amount,
+    });
+
+    return { approveData: res.data, approveFetched: res.isFetched };
+};

package/src/enso-api/custom-instance.ts

@@ -0,0 +1,35 @@
+// import Axios from "axios";
+import { useAppStore } from "@/store";
+
+// export const AXIOS_INSTANCE = Axios.create({
+//     baseURL: "https://api.enso.finance",
+// });
+
+type CustomClient<T> = (data: {
+    url: string;
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    params?: Record<string, any>;
+    headers?: Record<string, any>;
+    data?: BodyType<unknown>;
+    signal?: AbortSignal;
+}) => Promise<T>;
+
+export const useCustomClient = <T>(): CustomClient<T> => {
+    const token = useAppStore((state) => state.ensoApiToken);
+
+    return async ({ url, method, params, data }) => {
+        const response = await fetch(url + "?" + new URLSearchParams(params), {
+            method,
+            headers: { ...data?.headers, Authorization: `Bearer ${token}` },
+            ...(data ? { body: JSON.stringify(data) } : {}),
+        });
+
+        return response.json();
+    };
+};
+
+export default useCustomClient;
+
+export type ErrorType<ErrorData> = ErrorData;
+
+export type BodyType<BodyData> = BodyData & { headers?: any };