@7kprotocol/sdk-ts 3.6.0 → 3.6.1-beta.1

package/lib/esm/features/swap/buildTxV2.js

@@ -1,223 +0,0 @@
-import { coinWithBalance, Transaction, } from "@mysten/sui/transactions";
-import { isValidSuiAddress, normalizeStructTag } from "@mysten/sui/utils";
-import { groupSwapRoutes } from "../../libs/groupSwapRoutes";
-import { swapWithRoute } from "../../libs/swapWithRoute";
-import { isBluefinXRouting, } from "../../types/aggregator";
-import { SuiUtils } from "../../utils/sui";
-import { buildBluefinXTx, settle, updatePythPriceFeedsIfAny, validateRoutes, } from "./buildTx";
-import { getConfig } from "./config";
-/**
- * Wave-based transaction builder that optimizes swap execution by:
- * 1. Grouping swaps into execution waves based on readiness
- * 2. Merging redundant swaps to the same pool within each wave
- * 3. Processing waves sequentially, passing intermediate tokens between waves
- */
-export const buildTxV2 = async (params) => {
-    return buildTxV2Int(params);
-};
-export const buildTxV2Int = async ({ quoteResponse, accountAddress, slippage, commission: __commission, devInspect, extendTx, isSponsored, }, beforeBuildBluefinXTx) => {
-    const isBluefinX = isBluefinXRouting(quoteResponse);
-    const _commission = {
-        ...__commission,
-        commissionBps: isBluefinX ? 0 : __commission.commissionBps,
-    };
-    const { tx: _tx, coinIn: _coinIn } = extendTx || {};
-    let coinOut;
-    if (isBluefinX && devInspect) {
-        throw new Error("BluefinX tx is sponsored, skip devInspect");
-    }
-    if (!accountAddress) {
-        throw new Error("Sender address is required");
-    }
-    if (!quoteResponse.routes) {
-        throw new Error("Invalid quote response: 'routes' are required");
-    }
-    if (!isValidSuiAddress(_commission.partner)) {
-        throw new Error("Invalid commission partner address");
-    }
-    const tx = _tx || new Transaction();
-    const routes = groupSwapRoutes(quoteResponse);
-    validateRoutes(routes, isSponsored);
-    const splits = routes.map((group) => group[0]?.amount ?? "0");
-    const coinIn = _coinIn ||
-        tx.add(coinWithBalance({
-            type: quoteResponse.tokenIn,
-            balance: BigInt(quoteResponse.swapAmountWithDecimal),
-            useGasCoin: !isSponsored && !isBluefinX,
-        }));
-    const coinData = tx.splitCoins(coinIn, splits);
-    SuiUtils.transferOrDestroyZeroCoin(tx, quoteResponse.tokenIn, coinIn, accountAddress);
-    const pythMap = await updatePythPriceFeedsIfAny(tx, [quoteResponse]);
-    const config = await getConfig();
-    const finalCoins = await optimize(pythMap, config, routes, coinData, tx, accountAddress);
-    // Merge all final coins
-    if (finalCoins.length > 0) {
-        const mergeCoin = tx.add(settle(finalCoins, quoteResponse, Math.floor(+slippage * 10000), _commission));
-        if (!extendTx) {
-            tx.transferObjects([mergeCoin], tx.pure.address(accountAddress));
-        }
-        else {
-            coinOut = mergeCoin;
-        }
-    }
-    if (isBluefinX) {
-        beforeBuildBluefinXTx?.(tx, coinOut);
-        return {
-            tx: await buildBluefinXTx(tx, accountAddress, quoteResponse),
-            coinOut,
-        };
-    }
-    tx.setSenderIfNotSet(accountAddress);
-    return { tx, coinOut };
-};
-const optimize = async (pythMap, config, routes, coinData, tx, accountAddress) => {
-    // Initialize route states with split coins
-    const routeStates = routes.map((route, index) => ({
-        routeIndex: index,
-        currentHopIndex: 0,
-        currentCoin: coinData[index],
-        swaps: route,
-        completed: false,
-    }));
-    const finalCoins = [];
-    const coinTypeOut = routes[0][routes[0].length - 1].assetOut;
-    // Execute swaps in waves
-    while (true) {
-        const readyHops = [];
-        routeStates.forEach((state) => {
-            if (state.completed)
-                return;
-            if (state.currentHopIndex >= state.swaps.length) {
-                state.completed = true;
-                finalCoins.push(state.currentCoin);
-                return;
-            }
-            const swap = state.swaps[state.currentHopIndex];
-            readyHops.push({
-                routeIndex: state.routeIndex,
-                hopIndex: state.currentHopIndex,
-                swap,
-                inputCoin: state.currentCoin,
-            });
-        });
-        if (readyHops.length === 0)
-            break;
-        // Group hops by pool for merging opportunities
-        const poolGroups = new Map();
-        readyHops.forEach((hop) => {
-            const poolKey = `${hop.swap.poolId}|${hop.swap.assetIn}|${hop.swap.assetOut}`;
-            if (!poolGroups.has(poolKey)) {
-                poolGroups.set(poolKey, {
-                    swap: hop.swap,
-                    hops: [],
-                });
-            }
-            poolGroups.get(poolKey).hops.push(hop);
-        });
-        // Execute each pool group in this wave
-        const wavePromises = [];
-        for (const group of poolGroups.values()) {
-            const { swap, hops } = group;
-            // For merged swaps, we need to combine input coins first
-            const wavePromise = (async () => {
-                let combinedCoin;
-                if (hops.length > 1) {
-                    // Merge all input coins for this pool
-                    const inputCoins = hops.map((h) => h.inputCoin);
-                    tx.mergeCoins(inputCoins[0], inputCoins.slice(1));
-                    combinedCoin = inputCoins[0];
-                }
-                else {
-                    combinedCoin = hops[0].inputCoin;
-                }
-                // Execute the swap with the combined coin
-                const resultCoin = await swapWithRoute({
-                    route: [swap],
-                    inputCoinObject: combinedCoin,
-                    currentAccount: accountAddress,
-                    tx,
-                    config,
-                    pythMap,
-                });
-                if (!resultCoin) {
-                    throw new Error(`Swap failed for pool ${swap.poolId}`);
-                }
-                if (hops[0].swap.assetOut === coinTypeOut) {
-                    finalCoins.push(resultCoin);
-                    hops.forEach((hop) => {
-                        const state = routeStates[hop.routeIndex];
-                        state.completed = true;
-                        state.currentHopIndex++;
-                    });
-                    return;
-                }
-                // For merged swaps, we need to split the output proportionally
-                if (hops.length > 1) {
-                    // Split output proportionally (except the last one which gets the remainder)
-                    const splitAmounts = hops
-                        .slice(1)
-                        .map((hop) => hop.swap.returnAmount);
-                    const splitCoins = splitAmounts.length > 0
-                        ? [resultCoin, ...tx.splitCoins(resultCoin, splitAmounts)]
-                        : [resultCoin];
-                    // Assign split coins back to routes
-                    hops.forEach((hop, index) => {
-                        const state = routeStates[hop.routeIndex];
-                        state.currentCoin = splitCoins[index];
-                        state.currentHopIndex++;
-                    });
-                }
-                else {
-                    // Single swap - simply update the route state
-                    const state = routeStates[hops[0].routeIndex];
-                    state.currentCoin = resultCoin;
-                    state.currentHopIndex++;
-                }
-            })();
-            wavePromises.push(wavePromise);
-        }
-        // Wait for all swaps in this wave to complete
-        await Promise.all(wavePromises);
-    }
-    return finalCoins;
-};
-/**
- * execute multiple swap in single transaction
- *
- * User must handle the coins from return
- * @param param - MultiSwapParams
- * @returns a map of coinType to coinObject
- */
-export const multiSwap = async ({ sender, slippageBps, swaps, tx, commission, }) => {
-    if (swaps.some((s) => isBluefinXRouting(s.quote))) {
-        throw Error("BluefinX routing not supported yet");
-    }
-    // update oracles price if any
-    const pythMap = await updatePythPriceFeedsIfAny(tx, swaps.map((s) => s.quote));
-    const map = {};
-    const config = await getConfig();
-    for (const { quote: sorResponse, coinIn } of swaps) {
-        const routes = groupSwapRoutes(sorResponse);
-        const splits = routes.map((group) => group[0]?.amount ?? "0");
-        const coinData = splits.length === 1
-            ? [coinIn]
-            : [coinIn, ...tx.splitCoins(coinIn, splits.slice(1))];
-        const coinObjects = await optimize(pythMap, config, routes, coinData, tx, sender);
-        if (coinObjects.length > 0) {
-            const mergeCoin = tx.add(settle(coinObjects, sorResponse, slippageBps, commission));
-            if (!map[normalizeStructTag(sorResponse.tokenOut)]) {
-                map[normalizeStructTag(sorResponse.tokenOut)] = [];
-            }
-            map[normalizeStructTag(sorResponse.tokenOut)].push(mergeCoin);
-        }
-    }
-    const result = {};
-    for (const [tokenOut, coins] of Object.entries(map)) {
-        if (coins.length > 1) {
-            tx.mergeCoins(coins[0], coins.slice(1));
-        }
-        result[tokenOut] = coins[0];
-    }
-    tx.setSenderIfNotSet(sender);
-    return result;
-};

package/lib/esm/features/swap/config.js

@@ -1,150 +0,0 @@
-import { Config as _Config } from "../../config";
-import { fetchClient } from "../../config/fetchClient";
-import { API_ENDPOINTS } from "../../constants/apiEndpoints";
-export const DEFAULT_CONFIG = {
-    aftermath: {
-        name: "Aftermath",
-        package: "0xc4049b2d1cc0f6e017fda8260e4377cecd236bd7f56a54fee120816e72e2e0dd",
-        poolRegistry: "0xfcc774493db2c45c79f688f88d28023a3e7d98e4ee9f48bbf5c7990f651577ae",
-        protocolFeeVault: "0xf194d9b1bcad972e45a7dd67dd49b3ee1e3357a00a50850c52cd51bb450e13b4",
-        treasury: "0x28e499dff5e864a2eafe476269a4f5035f1c16f338da7be18b103499abf271ce",
-        insuranceFund: "0xf0c40d67b078000e18032334c3325c47b9ec9f3d9ae4128be820d54663d14e3b",
-        referralVault: "0x35d35b0e5b177593d8c3a801462485572fc30861e6ce96a55af6dc4730709278",
-    },
-    bluefin: {
-        name: "Bluefin",
-        package: "0x67b34b728c4e28e704dcfecf7c5cf55c7fc593b6c65c20d1836d97c209c1928a",
-        globalConfig: "0x03db251ba509a8d5d8777b6338836082335d93eecbdd09a11e190a1cff51c352",
-    },
-    bluemove: {
-        name: "Bluemove",
-        package: "0x08cd33481587d4c4612865b164796d937df13747d8c763b8a178c87e3244498f",
-        dexInfo: "0x3f2d9f724f4a1ce5e71676448dc452be9a6243dac9c5b975a588c8c867066e92",
-    },
-    cetus: {
-        name: "Cetus",
-        package: "0xfbb32ac0fa89a3cb0c56c745b688c6d2a53ac8e43447119ad822763997ffb9c3",
-        globalConfig: "0xdaa46292632c3c4d8f31f23ea0f9b36a28ff3677e9684980e4438403a67a3d8f",
-    },
-    deepbook_v3: {
-        name: "Deepbook V3",
-        package: "",
-        sponsor: "0x951a01360d85b06722edf896852bf8005b81cdb26375235c935138987f629502",
-        sponsorFund: "0xf245e7a4b83ed9a26622f5818a158c2ba7a03b91e62717b557a7df1d4dab38df",
-    },
-    flowx: {
-        name: "Flowx Finance",
-        package: "0xba153169476e8c3114962261d1edc70de5ad9781b83cc617ecc8c1923191cae0",
-        container: "0xb65dcbf63fd3ad5d0ebfbf334780dc9f785eff38a4459e37ab08fa79576ee511",
-    },
-    flowx_v3: {
-        name: "Flowx Finance V3",
-        package: "0xe882cd54551e73e64ff5b257146a0c5264546974cf00d78ecc871017cb22df67",
-        registry: "0x27565d24a4cd51127ac90e4074a841bbe356cca7bf5759ddc14a975be1632abc",
-        version: "0x67624a1533b5aff5d0dfcf5e598684350efd38134d2d245f475524c03a64e656",
-    },
-    kriya: {
-        name: "Kriya",
-        package: "0xa0eba10b173538c8fecca1dff298e488402cc9ff374f8a12ca7758eebe830b66",
-    },
-    kriya_v3: {
-        name: "Kriya V3",
-        package: "0x0d7305a7475ed54adc905365bd081939a81926636b4c438cf2f75f4924b8d960",
-        version: "0xf5145a7ac345ca8736cf8c76047d00d6d378f30e81be6f6eb557184d9de93c78",
-    },
-    obric: {
-        name: "Obric",
-        package: "0xb84e63d22ea4822a0a333c250e790f69bf5c2ef0c63f4e120e05a6415991368f",
-        pythState: "0x1f9310238ee9298fb703c3419030b35b22bb1cc37113e3bb5007c99aec79e5b8",
-    },
-    springsui: {
-        name: "SpringSui",
-        package: "0x82e6f4f75441eae97d2d5850f41a09d28c7b64a05b067d37748d471f43aaf3f7",
-    },
-    stsui: {
-        name: "AlphaFi stSUI",
-        package: "0x059f94b85c07eb74d2847f8255d8cc0a67c9a8dcc039eabf9f8b9e23a0de2700",
-    },
-    suiswap: {
-        name: "SuiSwap",
-        package: "0xd075d51486df71e750872b4edf82ea3409fda397ceecc0b6aedf573d923c54a0",
-    },
-    turbos: {
-        name: "Turbos Finance",
-        package: "0xd02012c71c1a6a221e540c36c37c81e0224907fe1ee05bfe250025654ff17103",
-        version: "0xf1cf0e81048df168ebeb1b8030fad24b3e0b53ae827c25053fff0779c1445b6f",
-    },
-    steamm: {
-        name: "Steamm",
-        package: "0x5ef2a1bca239764c8381ba26b758833060eadb8903682e4fb15e58c6406e2488",
-        script: "0x0755429cba577decc090009348987a89f4fb8397da27a3eaafc366794078af7d",
-        oracle: "0xe84b649199654d18c38e727212f5d8dacfc3cf78d60d0a7fc85fd589f280eb2b",
-    },
-    magma: {
-        name: "Magma",
-        package: "0x49e9f06c58a36830fe0d83291f002012e72b00a4ec9b3a6304c40fc5712bb6e3",
-        globalConfig: "0x4c4e1402401f72c7d8533d0ed8d5f8949da363c7a3319ccef261ffe153d32f8a",
-    },
-    haedal_pmm: {
-        name: "Haedal PMM",
-        package: "0x486622af8a7250a192e6ee97eed4f54e30343b764d9148bf1535b55f85155204",
-    },
-    momentum: {
-        name: "Momentum",
-        package: "0xcf60a40f45d46fc1e828871a647c1e25a0915dec860d2662eb10fdb382c3c1d1",
-        version: "0x2375a0b1ec12010aaea3b2545acfa2ad34cfbba03ce4b59f4c39e1e25eed1b2a",
-    },
-    bluefinx: {
-        name: "BluefinX",
-        package: "0x9633d611ea4b3a30751135cede2c7871980955473c1c7c883d43567e7e9b164e",
-        globalConfig: "0xc6b29a60c3924776bedc78df72c127ea52b86aeb655432979a38f13d742dedaa",
-    },
-    sevenk_v1: {
-        name: "7K DEX",
-        package: "0x4142285db093ba0cf0623b3cbc07372fb4f5ed00af1fb62be6d55f49a42c0b0e",
-        oracle: "0x8c36ea167c5e6da8c3d60b4fc897416105dcb986471bd81cfbfd38720a4487c0",
-    },
-    fullsail: {
-        name: "Fullsail",
-        package: "0xb3b98d4fda36acc2c2e66dba61f9149b341c38e97a532af802ebbb0c037b9d1f",
-        globalConfig: "0xe93baa80cb570b3a494cbf0621b2ba96bc993926d34dc92508c9446f9a05d615",
-        rewarderGlobalVault: "0xfb971d3a2fb98bde74e1c30ba15a3d8bef60a02789e59ae0b91660aeed3e64e1",
-        priceProvider: "0x854b2d2c0381bb656ec962f8b443eb082654384cf97885359d1956c7d76e33c9",
-        stats: "0x6822a33d1d971e040c32f7cc74507010d1fe786f7d06ab89135083ddb07d2dc2",
-    },
-    cetus_dlmm: {
-        name: "Cetus DLMM",
-        package: "0xa4c6f46bd6b456e6477bcddf0652e0d2d8fb4767e306533e6e885302ee28cfab",
-        globalConfig: "0xf31b605d117f959b9730e8c07b08b856cb05143c5e81d5751c90d2979e82f599",
-        version: "0x05370b2d656612dd5759cbe80463de301e3b94a921dfc72dd9daa2ecdeb2d0a8",
-    },
-    ferra_dlmm: {
-        name: "Ferra DLMM",
-        package: "0x5a5c1d10e4782dbbdec3eb8327ede04bd078b294b97cfdba447b11b846b383ac",
-        globalConfig: "0x5c9dacf5a678ea15b8569d65960330307e23d429289ca380e665b1aa175ebeca",
-    },
-    ferra_clmm: {
-        name: "Ferra CLMM",
-        package: "0xc895342d87127c9c67b76c8ad7f9a22b8bfe1dcdc2c5af82bd85266783115e31",
-        integrate: "0x1dd5538aeb1066315969d87ae9a920ce2692824385342f49854b764ac730a64b",
-        globalConfig: "0x2cd8382c19e6994f16df204e9b8cddd04bdc486c251de75ac66ac4e48e3e7081",
-    },
-};
-let config = DEFAULT_CONFIG;
-let configTs = 0;
-export async function getConfig() {
-    const ttl = 60;
-    if (config && Date.now() - configTs < ttl * 1000) {
-        return config;
-    }
-    try {
-        const response = await fetchClient(`${_Config.getApi() || API_ENDPOINTS.MAIN}/config`);
-        const quoteResponse = (await response.json());
-        config = { ...config, ...quoteResponse };
-        configTs = Date.now();
-        return config;
-    }
-    catch (_) {
-        return DEFAULT_CONFIG;
-    }
-}

package/lib/esm/features/swap/estimateGasFee.js

@@ -1,41 +0,0 @@
-import { SUI_DECIMALS } from "@mysten/sui/utils";
-import { Config } from "../../config";
-import { isBluefinXRouting } from "../../types/aggregator";
-import { formatBalance } from "../../utils/number";
-import { getSuiPrice } from "../prices";
-import { buildTx } from "./buildTx";
-import { BluefinXTx } from "../../libs/protocols/bluefinx/types";
-export async function estimateGasFee({ quoteResponse, accountAddress, slippage, suiPrice: _suiPrice, extendTx, commission, }) {
-    if (!accountAddress)
-        return 0;
-    // BluefinX is sponsored, no need to estimate gas fee
-    if (!accountAddress || isBluefinXRouting(quoteResponse))
-        return 0;
-    const result = await buildTx({
-        extendTx,
-        quoteResponse,
-        accountAddress,
-        slippage,
-        commission,
-        devInspect: true,
-    }).catch((err) => {
-        console.log("build tx error: ", err);
-        return undefined;
-    });
-    const { tx } = result || {};
-    if (!tx || tx instanceof BluefinXTx)
-        return 0;
-    const suiPrice = _suiPrice || (await getSuiPrice());
-    const suiDecimals = SUI_DECIMALS;
-    const { effects: { gasUsed, status }, } = await Config.getSuiClient().devInspectTransactionBlock({
-        sender: accountAddress,
-        transactionBlock: tx,
-    });
-    if (status.status !== "success")
-        return 0;
-    const fee = BigInt(gasUsed.computationCost) +
-        BigInt(gasUsed.storageCost) -
-        BigInt(gasUsed.storageRebate);
-    const feeUsd = Number(suiPrice) * Number(formatBalance(fee, suiDecimals));
-    return feeUsd;
-}

package/lib/esm/features/swap/executeTx.js

@@ -1,48 +0,0 @@
-import { Config } from "../../config";
-import { executeBluefinTx } from "../../libs/protocols/bluefinx/client";
-import { BluefinXTx } from "../../libs/protocols/bluefinx/types";
-/**
- * Execute a transaction after it is signed
- *
- * Automatically handle BluefinX transaction execution if needed
- * @example
- * ```ts
- * const { mutateAsync: signTransaction } = useSignTransaction();
- * const quoteResponse = await getQuote(...quoteParams);
- * const { tx } = await buildTx(...buildTxParams);
- * const {signature, bytes} = await signTransaction({
- *  transaction: tx instanceof BluefinXTx ? tx.txBytes : tx,
- * });
- * const res = await executeTx(tx, signature, bytes);
- * ```
- * @param tx - AggregatorTx - received from `buildTx`
- * @param signature - User signature after signing the transaction
- * @param signedTxBytes - Signed transaction bytes after signing the transaction
- * @param options - Options for the transaction
- * @returns `SuiTransactionBlockResponse`
- */
-export const executeTx = async (tx, signature, signedTxBytes, options) => {
-    const isBluefinTx = tx instanceof BluefinXTx;
-    const client = Config.getSuiClient();
-    let res;
-    if (isBluefinTx) {
-        try {
-            const result = await executeBluefinTx(tx, signature);
-            res = await client.waitForTransaction({
-                digest: result.txDigest,
-                options,
-            });
-        }
-        catch (e) {
-            throw Error(`Could not retrieve BluefinX transaction with quoteId: ${tx.quoteId} ${e}`);
-        }
-    }
-    else {
-        res = await client.executeTransactionBlock({
-            transactionBlock: signedTxBytes,
-            signature,
-            options,
-        });
-    }
-    return res;
-};

package/lib/esm/features/swap/getQuote.js

@@ -1,91 +0,0 @@
-import { normalizeStructTag, normalizeSuiObjectId } from "@mysten/sui/utils";
-import { Config } from "../../config";
-import { fetchClient } from "../../config/fetchClient";
-import { API_ENDPOINTS } from "../../constants/apiEndpoints";
-import { isBluefinXRouting, } from "../../types/aggregator";
-export const DEFAULT_SOURCES = [
-    "suiswap",
-    "turbos",
-    "cetus",
-    "bluemove",
-    "kriya",
-    "kriya_v3",
-    "aftermath",
-    "deepbook_v3",
-    "flowx",
-    "flowx_v3",
-    "bluefin",
-    "springsui",
-    "obric",
-    "stsui",
-    "steamm",
-    "steamm_oracle_quoter",
-    "steamm_oracle_quoter_v2",
-    "magma",
-    "haedal_pmm",
-    "momentum",
-    "sevenk_v1",
-    "fullsail",
-    "cetus_dlmm",
-    "ferra_dlmm",
-    "ferra_clmm",
-];
-export const ORACLE_BASED_SOURCES = new Set([
-    "obric",
-    "haedal_pmm",
-    "sevenk_v1",
-    "steamm_oracle_quoter",
-    "steamm_oracle_quoter_v2",
-]);
-export async function getQuote({ tokenIn, tokenOut, amountIn, sources: _sources = DEFAULT_SOURCES, commissionBps, targetPools, excludedPools, taker, isSponsored, maxPaths, }) {
-    let sources = _sources;
-    if (isSponsored) {
-        sources = _sources.filter((s) => !ORACLE_BASED_SOURCES.has(s));
-    }
-    const params = new URLSearchParams({
-        amount: amountIn,
-        from: normalizeStructTag(tokenIn),
-        to: normalizeStructTag(tokenOut),
-        sources: sources.join(","),
-    });
-    if (targetPools?.length) {
-        params.append("target_pools", targetPools.map((v) => normalizeSuiObjectId(v)).join(","));
-    }
-    if (excludedPools?.length) {
-        params.append("excluded_pools", excludedPools.map((v) => normalizeSuiObjectId(v)).join(","));
-    }
-    if (taker) {
-        params.append("taker", taker);
-    }
-    if (maxPaths) {
-        params.append("max_paths", maxPaths.toString());
-    }
-    const response = await fetchClient(`${Config.getApi() || API_ENDPOINTS.MAIN}/quote?${params}`);
-    if (!response.ok) {
-        let responseText;
-        try {
-            responseText = await response.text();
-        }
-        catch {
-            responseText = "Failed to fetch aggregator quote";
-        }
-        throw new Error(responseText);
-    }
-    const quoteResponse = (await response.json());
-    computeReturnAmountAfterCommission(quoteResponse, commissionBps);
-    return quoteResponse;
-}
-const computeReturnAmountAfterCommission = (quoteResponse, commissionBps) => {
-    const _commissionBps = isBluefinXRouting(quoteResponse) ? 0 : commissionBps;
-    if (quoteResponse.returnAmount && +quoteResponse.returnAmount > 0) {
-        quoteResponse.returnAmountAfterCommissionWithDecimal = ((BigInt(quoteResponse.returnAmountWithDecimal || 0) *
-            BigInt(10_000 - (_commissionBps ?? 0))) /
-            BigInt(10_000)).toString(10);
-        const exp = Math.round(+quoteResponse.returnAmountWithDecimal / +quoteResponse.returnAmount);
-        quoteResponse.returnAmountAfterCommission = (+quoteResponse.returnAmountAfterCommissionWithDecimal / exp).toString(10);
-    }
-    else {
-        quoteResponse.returnAmountAfterCommission = "";
-        quoteResponse.returnAmountAfterCommissionWithDecimal = "";
-    }
-};

package/lib/esm/features/swap/getSwapHistory.js

@@ -1,18 +0,0 @@
-import { fetchClient } from "../../config/fetchClient";
-import { API_ENDPOINTS } from "../../constants/apiEndpoints";
-import { formatQueryParams } from "../../libs/url";
-export async function getSwapHistory({ owner, offset = 0, limit = 10, tokenPair, }) {
-    const queryParams = {
-        addr: owner,
-        offset,
-        limit,
-        token_pair: tokenPair,
-    };
-    const paramsStr = formatQueryParams(queryParams);
-    const response = await fetchClient(`${API_ENDPOINTS.STATISTIC}/trading-history?${paramsStr}`);
-    if (!response.ok) {
-        throw new Error("Failed to fetch open limit orders");
-    }
-    const orders = (await response.json());
-    return orders;
-}

package/lib/esm/features/swap/index.js

@@ -1,6 +0,0 @@
-export * from "./buildTx";
-export * from "./buildTxV2";
-export * from "./estimateGasFee";
-export * from "./executeTx";
-export * from "./getQuote";
-export * from "./getSwapHistory";

package/lib/esm/libs/groupSwapRoutes.js

@@ -1,57 +0,0 @@
-import { denormalizeTokenType } from "../utils/token";
-export function groupSwapRoutes(quoteResponse) {
-    if (!quoteResponse.routes || !quoteResponse.swaps) {
-        return [];
-    }
-    const poolDetails = mapPoolIdsToDetails(quoteResponse.routes);
-    const items = getTxSorSwaps(quoteResponse.swaps, poolDetails);
-    const groupedItems = [];
-    let currentGroup = [];
-    for (let i = 0; i < items.length; i++) {
-        const item = items[i];
-        currentGroup.push(item);
-        const nextItem = items[i + 1];
-        if (!nextItem || BigInt(nextItem.amount) > 0n) {
-            groupedItems.push(currentGroup);
-            currentGroup = [];
-        }
-    }
-    if (currentGroup.length > 0) {
-        groupedItems.push(currentGroup);
-    }
-    return groupedItems;
-}
-function mapPoolIdsToDetails(routes) {
-    const poolTypes = {};
-    routes.forEach((route) => {
-        route.hops.forEach((hop) => {
-            poolTypes[hop.poolId] = hop.pool;
-        });
-    });
-    return poolTypes;
-}
-function getTxSorSwaps(swaps, poolDetails) {
-    return swaps.map((swap) => {
-        const pool = poolDetails[swap.poolId];
-        const assetIn = denormalizeTokenType(swap.assetIn);
-        const assetOut = denormalizeTokenType(swap.assetOut);
-        const coinX = {
-            type: denormalizeTokenType(pool?.allTokens?.[0]?.address),
-            decimals: pool?.allTokens?.[0]?.decimal,
-        };
-        const coinY = {
-            type: denormalizeTokenType(pool?.allTokens?.[1]?.address),
-            decimals: pool?.allTokens?.[0]?.decimal,
-        };
-        const swapXtoY = assetIn === coinX.type;
-        return {
-            ...swap,
-            pool,
-            assetIn,
-            assetOut,
-            coinX,
-            coinY,
-            swapXtoY,
-        };
-    });
-}

package/lib/esm/libs/protocols/aftermath/index.js

@@ -1,31 +0,0 @@
-import { BaseContract } from "../base";
-import { normalizeTokenType } from "../../../utils/token";
-export class AfterMathContract extends BaseContract {
-    async swap(tx) {
-        const poolId = this.swapInfo.poolId;
-        const returnAmount = this.swapInfo.returnAmount;
-        const coinInType = normalizeTokenType(this.swapInfo.assetIn);
-        const coinOutType = normalizeTokenType(this.swapInfo.assetOut);
-        const inputCoinObject = this.inputCoinObject;
-        const [lpCoinType] = this.getTypeParams();
-        if (!lpCoinType)
-            throw new Error("lpCoinType is not defined");
-        const config = this.config.aftermath;
-        const [tokenOut] = tx.moveCall({
-            target: `${config.package}::swap::swap_exact_in`,
-            typeArguments: [lpCoinType, coinInType, coinOutType],
-            arguments: [
-                tx.object(poolId),
-                tx.object(config.poolRegistry),
-                tx.object(config.protocolFeeVault),
-                tx.object(config.treasury),
-                tx.object(config.insuranceFund),
-                tx.object(config.referralVault),
-                inputCoinObject,
-                tx.pure.u64(returnAmount),
-                tx.pure.u64("1000000000000000000"), // slippage
-            ],
-        });
-        return tokenOut;
-    }
-}