@typus/typus-sdk 1.4.3-d → 1.4.3-f

package/src/typus-perp/user/tlp.ts

@@ -0,0 +1,234 @@
+import { burnLp, mintLp, updateLiquidityValue } from "../lp-pool/functions";
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { CLOCK } from "src/constants";
+import { LiquidityPool } from "../lp-pool/structs";
+import { PythClient, createPythClient, updatePyth } from "src/utils/pyth/pythClient";
+import { tokenType, typeArgToAsset, TOKEN } from "src/constants/token";
+import { harvestPerUserShare, stake, unstake } from "../stake-pool/functions";
+import { swap as _swap } from "../lp-pool/functions";
+import { unsubscribe as _unsubscribe } from "../stake-pool/functions";
+import { priceInfoObjectIds, pythStateId } from "src/utils/pyth/constant";
+import { NETWORK } from "..";
+
+export async function mintStakeLp(
+    config: {
+        REGISTRY: { LP_POOL_REGISTRY: string; TREASURY_CAPS: string; STAKE_POOL_REGISTRY: string };
+        OBJECT: { TYPUS_PERP_VERSION: string };
+        TOKEN: { TLP: string };
+    },
+    input: {
+        pythClient: PythClient;
+        tx: TransactionBlock;
+        lpPool: LiquidityPool;
+        coins: string[];
+        cTOKEN: TOKEN;
+        amount: string;
+        userShareId: string | null;
+    }
+): Promise<TransactionBlock> {
+    // update pyth oracle
+    const tokens = input.lpPool.tokenPools.map((p) => typeArgToAsset("0x" + p.tokenType.name));
+
+    await updatePyth(input.pythClient, input.tx, tokens);
+    const cToken = tokenType[NETWORK][input.cTOKEN];
+
+    for (let token of tokens) {
+        updateLiquidityValue(input.tx, tokenType[NETWORK][token], {
+            version: config.OBJECT.TYPUS_PERP_VERSION,
+            registry: config.REGISTRY.LP_POOL_REGISTRY,
+            index: BigInt(0),
+            pythState: pythStateId[NETWORK],
+            oracle: priceInfoObjectIds[NETWORK][token],
+            clock: CLOCK,
+        });
+    }
+
+    var coin;
+
+    if (input.cTOKEN == "SUI") {
+        [coin] = input.tx.splitCoins(input.tx.gas, [input.amount]);
+    } else {
+        const destination = input.coins.pop()!;
+
+        if (input.coins.length > 0) {
+            input.tx.mergeCoins(destination, input.coins);
+        }
+
+        [coin] = input.tx.splitCoins(destination, [input.amount]);
+    }
+
+    const lpCoin = mintLp(input.tx, [cToken, config.TOKEN.TLP], {
+        version: config.OBJECT.TYPUS_PERP_VERSION,
+        registry: config.REGISTRY.LP_POOL_REGISTRY,
+        treasuryCaps: config.REGISTRY.TREASURY_CAPS,
+        index: BigInt(0),
+        pythState: pythStateId[NETWORK],
+        oracle: priceInfoObjectIds[NETWORK][input.cTOKEN],
+        coin,
+        clock: CLOCK,
+    });
+
+    stake(input.tx, config.TOKEN.TLP, {
+        version: config.OBJECT.TYPUS_PERP_VERSION,
+        registry: config.REGISTRY.STAKE_POOL_REGISTRY,
+        index: BigInt(0),
+        lpToken: lpCoin,
+        clock: CLOCK,
+        userShareId: input.userShareId ? BigInt(input.userShareId) : null,
+    });
+
+    return input.tx;
+}
+
+export async function unstakeBurn(
+    config: {
+        REGISTRY: { LP_POOL_REGISTRY: string; TREASURY_CAPS: string; STAKE_POOL_REGISTRY: string };
+        OBJECT: { TYPUS_PERP_VERSION: string };
+        TOKEN: { TLP: string };
+    },
+    input: {
+        pythClient: PythClient;
+        tx: TransactionBlock;
+        lpPool: LiquidityPool;
+        cTOKEN: TOKEN;
+        userShareId: string;
+        share: string | null;
+        user: string;
+    }
+): Promise<TransactionBlock> {
+    // update pyth oracle
+    const tokens = input.lpPool.tokenPools.map((p) => typeArgToAsset("0x" + p.tokenType.name));
+
+    await updatePyth(input.pythClient, input.tx, tokens);
+    const cToken = tokenType[NETWORK][input.cTOKEN];
+    const oracle = priceInfoObjectIds[NETWORK][input.cTOKEN];
+
+    for (let token of tokens) {
+        updateLiquidityValue(input.tx, tokenType[NETWORK][token], {
+            version: config.OBJECT.TYPUS_PERP_VERSION,
+            registry: config.REGISTRY.LP_POOL_REGISTRY,
+            index: BigInt(0),
+            pythState: pythStateId[NETWORK],
+            oracle: priceInfoObjectIds[NETWORK][token],
+            clock: CLOCK,
+        });
+    }
+
+    const lpCoin = unstake(input.tx, config.TOKEN.TLP, {
+        version: config.OBJECT.TYPUS_PERP_VERSION,
+        registry: config.REGISTRY.STAKE_POOL_REGISTRY,
+        index: BigInt(0),
+        userShareId: BigInt(input.userShareId),
+        clock: CLOCK,
+        unstakedShares: input.share ? BigInt(input.share) : null,
+    });
+
+    const coin = burnLp(input.tx, [cToken, config.TOKEN.TLP], {
+        version: config.OBJECT.TYPUS_PERP_VERSION,
+        registry: config.REGISTRY.LP_POOL_REGISTRY,
+        treasuryCaps: config.REGISTRY.TREASURY_CAPS,
+        index: BigInt(0),
+        pythState: pythStateId[NETWORK],
+        oracle,
+        coin: lpCoin,
+        clock: CLOCK,
+    });
+
+    input.tx.transferObjects([coin], input.user);
+
+    return input.tx;
+}
+
+export async function swap(
+    config: {
+        REGISTRY: { LP_POOL_REGISTRY: string; TREASURY_CAPS: string; STAKE_POOL_REGISTRY: string };
+        OBJECT: { TYPUS_PERP_VERSION: string };
+        TOKEN: { TLP: string };
+    },
+    input: {
+        pythClient: PythClient;
+        tx: TransactionBlock;
+        coins: string[];
+        FROM_TOKEN: TOKEN;
+        TO_TOKEN: TOKEN;
+        amount: string;
+        user: string;
+    }
+): Promise<TransactionBlock> {
+    await updatePyth(input.pythClient, input.tx, [input.FROM_TOKEN, input.TO_TOKEN]);
+    const fromToken = tokenType[NETWORK][input.FROM_TOKEN];
+    const toToken = tokenType[NETWORK][input.TO_TOKEN];
+
+    var coin;
+
+    if (input.FROM_TOKEN == "SUI") {
+        [coin] = input.tx.splitCoins(input.tx.gas, [input.amount]);
+    } else {
+        const destination = input.coins.pop()!;
+
+        if (input.coins.length > 0) {
+            input.tx.mergeCoins(destination, input.coins);
+        }
+
+        [coin] = input.tx.splitCoins(destination, [input.amount]);
+    }
+
+    const token = _swap(input.tx, [fromToken, toToken], {
+        version: config.OBJECT.TYPUS_PERP_VERSION,
+        registry: config.REGISTRY.LP_POOL_REGISTRY,
+        pythState: pythStateId[NETWORK],
+        clock: CLOCK,
+        index: BigInt(0),
+        oracleFromToken: priceInfoObjectIds[NETWORK][input.FROM_TOKEN],
+        oracleToToken: priceInfoObjectIds[NETWORK][input.TO_TOKEN],
+        fromCoin: coin,
+        minToAmount: BigInt(0),
+    });
+
+    input.tx.transferObjects([token], input.user);
+
+    return input.tx;
+}
+
+export async function unsubscribe(
+    config: {
+        REGISTRY: { STAKE_POOL_REGISTRY: string };
+        OBJECT: { TYPUS_PERP_VERSION: string };
+        TOKEN: { TLP: string };
+    },
+    input: {
+        tx: TransactionBlock;
+        userShareId: string;
+        share: string | null;
+    }
+): Promise<TransactionBlock> {
+    _unsubscribe(input.tx, config.TOKEN.TLP, {
+        version: config.OBJECT.TYPUS_PERP_VERSION,
+        registry: config.REGISTRY.STAKE_POOL_REGISTRY,
+        index: BigInt(0),
+        userShareId: BigInt(input.userShareId),
+        clock: CLOCK,
+        unsubscribedShares: input.share ? BigInt(input.share) : null,
+    });
+    return input.tx;
+}
+
+export async function harvest(
+    config: {
+        REGISTRY: { STAKE_POOL_REGISTRY: string };
+        OBJECT: { TYPUS_PERP_VERSION: string };
+    },
+    input: {
+        tx: TransactionBlock;
+        userShareId: string;
+    }
+): Promise<TransactionBlock> {
+    harvestPerUserShare(input.tx, "0x2::sui::SUI", {
+        version: config.OBJECT.TYPUS_PERP_VERSION,
+        registry: config.REGISTRY.STAKE_POOL_REGISTRY,
+        index: BigInt(0),
+        userShareId: BigInt(input.userShareId),
+        clock: CLOCK,
+    });
+    return input.tx;
+}

package/src/user/view-function.ts

@@ -0,0 +1,33 @@
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { SuiClient } from "@mysten/sui.js/client";
+import { BcsReader } from "@mysten/bcs";
+
+const SENDER = "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
+export async function getUserMetadata(input: {
+    provider: SuiClient;
+    typusPackageId: string;
+    typusEcosystemVersion: string;
+    typusUserRegistry: string;
+    user: string;
+}): Promise<string[]> {
+    let transactionBlock = new TransactionBlock();
+    transactionBlock.moveCall({
+        target: `${input.typusPackageId}::user::get_user_metadata`,
+        typeArguments: [],
+        arguments: [
+            transactionBlock.pure(input.typusEcosystemVersion),
+            transactionBlock.pure(input.typusUserRegistry),
+            transactionBlock.pure(input.user),
+        ],
+    });
+    let results = (await input.provider.devInspectTransactionBlock({ sender: SENDER, transactionBlock })).results;
+    // console.log(JSON.stringify(results));
+    // @ts-ignore
+    let bytes = results[results.length - 1].returnValues[0][0];
+    // console.log(JSON.stringify(bytes));
+    let reader = new BcsReader(new Uint8Array(bytes));
+    reader.readULEB();
+    return reader.readVec((reader) => {
+        return reader.read64();
+    });
+}

package/src/utils/api/defillama/tvl.ts

@@ -0,0 +1,11 @@
+export async function getTvl(): Promise<number> {
+    let response = await fetch("https://api.llama.fi/tvl/typus-finance", {
+        method: "GET",
+    });
+
+    // console.log(response);
+    let data = await response.json();
+    // console.log(data);
+
+    return data;
+}

package/src/utils/api/price.ts

@@ -0,0 +1,101 @@
+const apiUrl = "https://us-central1-aqueous-freedom-378103.cloudfunctions.net/db-price";
+
+export async function getPairPrices(pair: string, startTs: string, endTs: string) {
+    const queryParams = new URLSearchParams({
+        pair,
+        startTs,
+        endTs,
+    });
+
+    // Append the query parameters to the URL
+    const apiUrlWithParams = `${apiUrl}?${queryParams.toString()}`;
+
+    let response = await fetch(apiUrlWithParams, {
+        method: "GET",
+        headers: { "Content-Type": "application/json" },
+    });
+
+    if (response.ok) {
+        let data = await response.json();
+        return data;
+    }
+}
+
+export async function getLatestPrice(pair: string): Promise<string> {
+    const currentTimestampInSeconds: number = Math.floor(new Date().getTime() / 1000);
+    const minuteAgo = currentTimestampInSeconds - 60;
+    try {
+        let res: any[] = await getPairPrices(pair, minuteAgo.toString(), currentTimestampInSeconds.toString());
+        if (res.at(-1)) {
+            return res.at(-1).price;
+        }
+    } catch (e) {
+        console.log(e);
+        return "0";
+    }
+    return "0";
+}
+
+export async function getPythLatestPrice() {
+    // Append the query parameters to the URL
+    const apiUrlWithParams =
+        "https://hermes.pyth.network/api/latest_price_feeds?ids[]=0x23d7315113f5b1d3ba7a83604c44b94d79f4fd69af77f804fc7f920a6dc65744&ids[]=0xe5b274b2611143df055d6e7cd8d93fe1961716bcd4dca1cad87a83bc1e78c1ef&ids[]=0xeaa020c61cc479712813461ce153894a96a6c00b21ed0cfc2798d1f9a9e9c94a&ids[]=0xe62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43&ids[]=0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace&ids[]=0xef0d8b6fda2ceba41da15d4095d1da392a0d2f8ed0c6c7bc0f4cfac8c280b56d&ids[]=0xf9c2e890443dd995d0baafc08eea3358be1ffb874f93f99c30b3816c460bbac3&ids[]=0x03ae4db29ed4ae33d323568895aa00337e658e348b37509f5372ae51f0af00d5&ids[]=0x2b89b9dc8fdf9f34709a5b106b472f0f39bb6ca9ce04b0fd7f2e971688e2e53b&ids[]=0xdcef50dd0a4cd2dcc17e45df1676dcb336a11a61c69df7a0299b0150c672d25c&ids[]=0x7a5bc1d2b56ad029048cd63964b3ad2776eadf812edc1a43a31406cb54bff592&ids[]=0x53614f1cb0c031d4af66c04cb9c756234adad0e1cee85303795091499a4084eb&ids[]=0x88250f854c019ef4f88a5c073d52a18bb1c6ac437033f5932cd017d24917ab46&ids[]=0xe393449f6aff8a4b6d3e1165a7c9ebec103685f3b41e60db4277b5b6d10e7326";
+
+    let response = await fetch(apiUrlWithParams, {
+        method: "GET",
+        headers: { "Content-Type": "application/json" },
+    });
+
+    let map = new Map<string, number>();
+
+    if (response.ok) {
+        let data = await response.json();
+
+        data.forEach((p) => {
+            let token = pythId[p.id];
+            let price = p.price.price / 10 ** -p.price.expo;
+            map.set(token, price);
+        });
+
+        return map;
+    }
+}
+
+export async function getLatestPriceUSD() {
+    let prices = (await getPythLatestPrice())!;
+
+    for (let pair of ["SUIFUD", "SUIBUCK", "SUIAFSUI", "SCASUI", "USDYUSDC"]) {
+        const currentTimestampInSeconds: number = Math.floor(new Date().getTime() / 1000);
+        const minuteAgo = currentTimestampInSeconds - 300;
+        let res: any[] = await getPairPrices(pair, minuteAgo.toString(), currentTimestampInSeconds.toString());
+        let price = res.at(-1).price;
+        let result;
+        if (pair.startsWith("SUI")) {
+            result = prices.get("SUI")! / Number(price);
+        } else if (pair.endsWith("SUI")) {
+            result = prices.get("SUI")! * Number(price);
+        } else {
+            result = Number(price);
+        }
+        prices.set(pair.replace("SUI", ""), result);
+    }
+
+    return prices;
+}
+
+const pythId = {
+    "23d7315113f5b1d3ba7a83604c44b94d79f4fd69af77f804fc7f920a6dc65744": "SUI",
+    e5b274b2611143df055d6e7cd8d93fe1961716bcd4dca1cad87a83bc1e78c1ef: "CETUS",
+    eaa020c61cc479712813461ce153894a96a6c00b21ed0cfc2798d1f9a9e9c94a: "USDC",
+    e62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43: "BTC",
+    ff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace: "ETH",
+    ef0d8b6fda2ceba41da15d4095d1da392a0d2f8ed0c6c7bc0f4cfac8c280b56d: "SOL",
+    f9c2e890443dd995d0baafc08eea3358be1ffb874f93f99c30b3816c460bbac3: "TURBOS",
+    "03ae4db29ed4ae33d323568895aa00337e658e348b37509f5372ae51f0af00d5": "APT",
+    "2b89b9dc8fdf9f34709a5b106b472f0f39bb6ca9ce04b0fd7f2e971688e2e53b": "USDT",
+    dcef50dd0a4cd2dcc17e45df1676dcb336a11a61c69df7a0299b0150c672d25c: "DOGE",
+    "7a5bc1d2b56ad029048cd63964b3ad2776eadf812edc1a43a31406cb54bff592": "INJ",
+    "53614f1cb0c031d4af66c04cb9c756234adad0e1cee85303795091499a4084eb": "SEI",
+    "88250f854c019ef4f88a5c073d52a18bb1c6ac437033f5932cd017d24917ab46": "NAVX",
+    e393449f6aff8a4b6d3e1165a7c9ebec103685f3b41e60db4277b5b6d10e7326: "USDY",
+};

package/src/utils/api/sentio/leader-board.ts

@@ -0,0 +1,259 @@
+// const apiUrl = "https://app.sentio.xyz/api/v1/insights/wayne/typus/query";
+
+// const depositorRequestData = {
+//     timeRange: {
+//         start: "-7d",
+//         end: "now",
+//         step: 3600,
+//     },
+//     limit: 200,
+//     queries: [
+//         {
+//             metricsQuery: {
+//                 query: "depositTvl",
+//                 alias: "",
+//                 id: "a",
+//                 labelSelector: {},
+//                 aggregate: {
+//                     op: "SUM",
+//                     grouping: ["user", "coin_symbol"],
+//                 },
+//                 functions: [],
+//                 disabled: true,
+//             },
+//             dataSource: "METRICS",
+//         },
+//         {
+//             priceQuery: {
+//                 id: "b",
+//                 alias: "",
+//                 coinId: [
+//                     {
+//                         symbol: "SUI",
+//                     },
+//                     {
+//                         symbol: "USDC",
+//                     },
+//                 ],
+//                 disabled: true,
+//             },
+//             dataSource: "PRICE",
+//         },
+//     ],
+//     formulas: [
+//         {
+//             expression: "a*b",
+//             alias: "{{user}}",
+//             id: "A",
+//             disabled: false,
+//         },
+//     ],
+// };
+
+// export async function getDepositorLeaderBoard(start?: string, end?: string, step?: number): Promise<LeaderBoard[]> {
+//     if (start) {
+//         depositorRequestData.timeRange.start = start;
+//     }
+//     if (end) {
+//         depositorRequestData.timeRange.end = end;
+//     }
+//     if (step) {
+//         depositorRequestData.timeRange.step = step;
+//     }
+//     const jsonData = JSON.stringify(depositorRequestData);
+
+//     let response = await fetch(apiUrl, {
+//         method: "POST",
+//         headers,
+//         body: jsonData,
+//     });
+
+//     try {
+//         let data = await response.json();
+
+//         let samples = data.results[0].matrix.samples;
+//         let len = samples.reduce((acc, curr) => (acc > curr.values.length ? acc : curr.values.length), 0) - 1;
+//         let leader_board: LeaderBoard[] = samples
+//             .map((element) => {
+//                 // console.log("metric:", element.metric, "values: ", element.values);
+//                 // console.log("user:", element.metric.labels.user, "score: ", element.values.at(-1).value);
+//                 let sum = element.values.reduce((acc, curr) => acc + curr.value / len, 0);
+
+//                 return {
+//                     user: element.metric.labels.user,
+//                     score: sum,
+//                 };
+//             })
+//             .filter((element) => element.score != 0);
+
+//         const userScoreMap: { [key: string]: number } = leader_board.reduce((map, obj) => {
+//             if (map[obj.user]) {
+//                 map[obj.user] += obj.score;
+//             } else {
+//                 map[obj.user] = obj.score;
+//             }
+//             return map;
+//         }, {});
+
+//         const result: LeaderBoard[] = Object.entries(userScoreMap).map(([user, score]) => ({ user, score }));
+//         result.sort((a, b) => b.score - a.score);
+//         // console.log(result);
+//         return result;
+//     } catch (e) {
+//         return [];
+//     }
+// }
+
+// const bidderRequestData = {
+//     timeRange: {
+//         start: "-7d",
+//         end: "now",
+//         step: 3600,
+//     },
+//     limit: 200,
+//     queries: [
+//         {
+//             metricsQuery: {
+//                 query: "totalNewBid",
+//                 alias: "",
+//                 id: "a",
+//                 labelSelector: {},
+//                 aggregate: {
+//                     op: "SUM",
+//                     grouping: ["user"],
+//                 },
+//                 functions: [],
+//                 disabled: false,
+//             },
+//             dataSource: "METRICS",
+//         },
+//     ],
+// };
+
+// export async function getBidderLeaderBoard(startTimestamp?: string, end?: string): Promise<LeaderBoard[]> {
+//     if (startTimestamp) {
+//         bidderRequestData.timeRange.start = startTimestamp;
+//     }
+//     if (end) {
+//         bidderRequestData.timeRange.end = end;
+//     }
+//     const jsonData = JSON.stringify(bidderRequestData);
+
+//     let response = await fetch(apiUrl, {
+//         method: "POST",
+//         headers,
+//         body: jsonData,
+//     });
+
+//     try {
+//         let data = await response.json();
+//         // console.log(data);
+//         let samples = data.results[0].matrix.samples;
+//         let leader_board: LeaderBoard[] = samples
+//             .map((element) => {
+//                 // console.log("metric:", element.metric, "values: ", element.values);
+//                 // console.log("user:", element.metric.labels.user, "score: ", element.values.at(-1).value);
+//                 let a = 0;
+//                 let log_0 = element.values.at(0);
+//                 if (log_0.timestamp == startTimestamp) {
+//                     a = log_0.value;
+//                 }
+//                 let b = element.values.at(-1).value;
+
+//                 return {
+//                     user: element.metric.labels.user,
+//                     score: b - a,
+//                 };
+//             })
+//             .filter((element) => element.score != 0);
+
+//         const userScoreMap: { [key: string]: number } = leader_board.reduce((map, obj) => {
+//             if (map[obj.user]) {
+//                 map[obj.user] += obj.score;
+//             } else {
+//                 map[obj.user] = obj.score;
+//             }
+//             return map;
+//         }, {});
+
+//         const result: LeaderBoard[] = Object.entries(userScoreMap).map(([user, score]) => ({ user, score }));
+//         result.sort((a, b) => b.score - a.score);
+//         // console.log(result);
+//         return result;
+//     } catch (e) {
+//         return [];
+//     }
+// }
+
+// interface LeaderBoard {
+//     user: string;
+//     score: number;
+// }
+
+export interface ExpLeaderBoard {
+    nft_id: string;
+    total_exp_earn: number;
+    owner: string | undefined;
+}
+
+export async function getExpLeaderBoardWithOwner(expLeaderBoard: ExpLeaderBoard[], ownerMap: Map<string, string>) {
+    return expLeaderBoard.map((l) => {
+        l.owner = ownerMap.get(l.nft_id);
+        return l;
+    });
+}
+
+const headers = {
+    "api-key": "tz3JJ6stG7Fux6ueRSRA5mdpC9U0lozI3",
+    "Content-Type": "application/json",
+};
+
+export async function getExpLeaderBoard(startTimestamp: string, endTimestamp?: string): Promise<ExpLeaderBoard[]> {
+    const apiUrl = "https://app.sentio.xyz/api/v1/analytics/typus/typus_v2/sql/execute";
+
+    const _endTimestamp = endTimestamp ? endTimestamp : "9999999999";
+
+    const requestData = {
+        sqlQuery: {
+            // sql: `SELECT S.distinct_id AS owner, SUM(E.exp_earn) AS total_exp_earn
+            //         FROM ExpUp E
+            //         JOIN (
+            //             SELECT number, distinct_id
+            //             FROM StakeNft
+            //             WHERE (number, timestamp) IN (
+            //                 SELECT number, MAX(timestamp) AS max_timestamp
+            //                 FROM StakeNft
+            //                 GROUP BY number
+            //             )
+            //         ) S ON E.number = S.number
+            //         WHERE E.timestamp >= ${startTimestamp} && E.timestamp < ${_endTimestamp}
+            //         GROUP BY owner
+            //         ORDER BY total_exp_earn DESC;`,
+            sql: `
+                SELECT E.nft_id as nft_id, SUM(E.exp_earn) as total_exp_earn
+                FROM ExpUp E
+                WHERE E.timestamp >= ${startTimestamp} && E.timestamp < ${_endTimestamp}
+                GROUP BY nft_id
+                ORDER BY total_exp_earn DESC;
+            `,
+            size: 200,
+        },
+    };
+
+    const jsonData = JSON.stringify(requestData);
+
+    let response = await fetch(apiUrl, {
+        method: "POST",
+        headers,
+        body: jsonData,
+    });
+
+    let data = await response.json();
+
+    return data.result.rows as ExpLeaderBoard[];
+}
+
+// (async () => {
+//     const res1 = await getExpLeaderBoard("0");
+//     console.log(res1);
+// })();