@7kprotocol/sdk-ts 1.0.0

package/lib/cjs/utils/token.js

@@ -0,0 +1,36 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeTokenType = normalizeTokenType;
+exports.denormalizeTokenType = denormalizeTokenType;
+exports.checkIsSui = checkIsSui;
+exports.getSuiscanTokenMetadata = getSuiscanTokenMetadata;
+const explorer_1 = require("../constants/explorer");
+const tokens_1 = require("../constants/tokens");
+function normalizeTokenType(type) {
+    return type === tokens_1.SUI_TYPE ? tokens_1.SUI_FULL_TYPE : type;
+}
+function denormalizeTokenType(type) {
+    return type === tokens_1.SUI_FULL_TYPE ? tokens_1.SUI_TYPE : type;
+}
+function checkIsSui(type) {
+    return type === tokens_1.SUI_FULL_TYPE || type === tokens_1.SUI_TYPE;
+}
+function getSuiscanTokenMetadata(type) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield fetch(`${explorer_1.EXPLORER.ADDRESS}/api/sui-backend/mainnet/api/coins/${denormalizeTokenType(type)}`);
+        if (!response.ok) {
+            throw new Error("Failed to fetch token metadata");
+        }
+        const data = yield response.json();
+        return Object.assign(Object.assign({}, data), { type: normalizeTokenType(data.type || "") });
+    });
+}

package/lib/esm/buildTx.js

@@ -0,0 +1,77 @@
+import { TransactionBlock, } from "@mysten/sui.js/transactions";
+import BigNumber from "bignumber.js";
+import { getSplitCoinForTx } from "./libs/getSplitCoinForTx";
+import { groupSwapRoutes } from "./libs/groupSwapRoutes";
+import { swapWithRoute } from "./libs/swapWithRoute";
+import { denormalizeTokenType } from "./utils/token";
+import { SuiUtils } from "./utils/sui";
+const _7K_PACKAGE_ID = "0xd48e7cdc9e92bec69ce3baa75578010458a0c5b2733d661a84971e8cef6806bc";
+const _7K_CONFIG = "0xc31272d90e0c36181b0153776c9d7c1516d4c1eca50fc2eb01f36d3f457ea90d";
+export const buildTx = async ({ quoteResponse, accountAddress, slippage, tx: _tx, commission: _commission, }) => {
+    if (!accountAddress || !quoteResponse.routes)
+        return;
+    const tx = _tx || new TransactionBlock();
+    const routes = groupSwapRoutes(quoteResponse);
+    const splits = routes.map((group) => group[0]?.amount ?? "0");
+    const { coinData } = await getSplitCoinForTx(accountAddress, quoteResponse.swapAmountWithDecimal, splits, denormalizeTokenType(quoteResponse.tokenIn), tx);
+    const coinObjects = [];
+    await Promise.all(routes.map(async (route, index) => {
+        const inputCoinObject = coinData[index];
+        const coinRes = await swapWithRoute({
+            route,
+            inputCoinObject,
+            currentAccount: accountAddress,
+            tx,
+        });
+        if (coinRes) {
+            coinObjects.push(coinRes);
+        }
+    }));
+    if (coinObjects.length > 0) {
+        const mergeCoin = coinObjects.length > 1
+            ? SuiUtils.mergeCoins(coinObjects, tx)
+            : coinObjects[0];
+        const minReceived = new BigNumber(1)
+            .minus(slippage)
+            .multipliedBy(quoteResponse.returnAmountWithDecimal)
+            .toFixed(0);
+        const commission = getCommission(tx, _commission);
+        tx.moveCall({
+            target: `${_7K_PACKAGE_ID}::settle::settle`,
+            typeArguments: [quoteResponse.tokenIn, quoteResponse.tokenOut],
+            arguments: [
+                tx.object(_7K_CONFIG),
+                tx.pure.u64(quoteResponse.swapAmountWithDecimal),
+                mergeCoin,
+                tx.pure.u64(minReceived),
+                tx.pure.u64(quoteResponse.returnAmountWithDecimal),
+                commission,
+            ],
+        });
+        tx.transferObjects([mergeCoin], tx.pure.address(accountAddress));
+    }
+    return tx;
+};
+const getCommission = (tx, commission) => {
+    if (commission) {
+        const [commissionInner] = tx.moveCall({
+            target: `${_7K_PACKAGE_ID}::commission::new`,
+            typeArguments: [],
+            arguments: [
+                tx.pure.address(commission.partner),
+                tx.pure.u64(commission.commissionBps),
+            ],
+        });
+        const [result] = tx.moveCall({
+            target: "0x1::option::some",
+            typeArguments: [`${_7K_PACKAGE_ID}::commission::Commission`],
+            arguments: [commissionInner],
+        });
+        return result;
+    }
+    return tx.moveCall({
+        target: "0x1::option::none",
+        typeArguments: [`${_7K_PACKAGE_ID}::commission::Commission`],
+        arguments: [],
+    })[0];
+};

package/lib/esm/constants/explorer.js

@@ -0,0 +1,3 @@
+export const EXPLORER = {
+    ADDRESS: `https://suiscan.xyz`,
+};

package/lib/esm/constants/tokens.js

@@ -0,0 +1,2 @@
+export const SUI_TYPE = "0x2::sui::SUI";
+export const SUI_FULL_TYPE = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";

package/lib/esm/estimateGasFee.js

@@ -0,0 +1,35 @@
+import BigNumber from "bignumber.js";
+import { SUI_DECIMALS } from "@mysten/sui.js/utils";
+import { buildTx } from "./buildTx";
+import { formatBalance } from "./utils/number";
+import { getSuiClient } from "./suiClient";
+import { getSuiPrice } from "./getSuiPrice";
+export async function estimateGasFee({ quoteResponse, accountAddress, slippage, suiPrice: _suiPrice, tx: _tx, commission, }) {
+    if (!accountAddress)
+        return 0;
+    const tx = await buildTx({
+        tx: _tx,
+        quoteResponse,
+        accountAddress,
+        slippage,
+        commission,
+    }).catch((err) => {
+        console.log("build tx error: ", err);
+        return undefined;
+    });
+    if (!tx)
+        return 0;
+    const suiPrice = _suiPrice || (await getSuiPrice());
+    const suiDecimals = SUI_DECIMALS;
+    const { effects: { gasUsed, status }, } = await getSuiClient().devInspectTransactionBlock({
+        sender: accountAddress,
+        transactionBlock: tx,
+    });
+    if (status.status !== "success")
+        return 0;
+    const fee = new BigNumber(gasUsed.computationCost)
+        .plus(gasUsed.storageCost)
+        .minus(gasUsed.storageRebate);
+    const feeUsd = new BigNumber(suiPrice).multipliedBy(formatBalance(fee, suiDecimals));
+    return feeUsd.toNumber();
+}

package/lib/esm/getQuote.js

@@ -0,0 +1,8 @@
+import { normalizeTokenType } from "./utils/token";
+export async function getQuote({ tokenIn, tokenOut, amountIn, }) {
+    const response = await fetch(`https://api.7k.ag/quote?amount=${amountIn}&from=${normalizeTokenType(tokenIn)}&to=${normalizeTokenType(tokenOut)}`);
+    if (!response.ok) {
+        throw new Error("Failed to fetch aggregator sor");
+    }
+    return response.json();
+}

package/lib/esm/getSuiPrice.js

@@ -0,0 +1,13 @@
+import BigNumber from "bignumber.js";
+import { getSuiscanTokenMetadata } from "./utils/token";
+import { SUI_TYPE } from "./constants/tokens";
+export async function getSuiPrice() {
+    try {
+        const suiToken = await getSuiscanTokenMetadata(SUI_TYPE);
+        const suiPrice = suiToken?.tokenPrice ?? "0";
+        return new BigNumber(suiPrice).toNumber();
+    }
+    catch (error) {
+        return 0;
+    }
+}

package/lib/esm/index.mjs

@@ -0,0 +1,15 @@
+export * from "./types/aggregator";
+import { getSuiClient, setSuiClient } from "./suiClient";
+import { getQuote } from "./getQuote";
+import { getSuiPrice } from "./getSuiPrice";
+import { estimateGasFee } from "./estimateGasFee";
+import { buildTx } from "./buildTx";
+export { getSuiClient, setSuiClient, getQuote, getSuiPrice, estimateGasFee, buildTx, };
+export default {
+    getSuiClient,
+    setSuiClient,
+    getQuote,
+    getSuiPrice,
+    estimateGasFee,
+    buildTx,
+};

package/lib/esm/libs/getCoinOjectIdsByAmount.js

@@ -0,0 +1,61 @@
+import BigNumber from "bignumber.js";
+import { getSuiClient } from "../suiClient";
+const orderByKey = (array, key, sortBy) => {
+    if (!array?.length) {
+        return;
+    }
+    let swapped;
+    const compareFunctionName = sortBy === "desc" ? "isLessThan" : "isGreaterThan";
+    do {
+        swapped = false;
+        for (let i = 0; i < array.length - 1; i++) {
+            if (new BigNumber(array[i][key])[compareFunctionName](array[i + 1][key])) {
+                const temp = array[i];
+                array[i] = array[i + 1];
+                array[i + 1] = temp;
+                swapped = true;
+            }
+        }
+    } while (swapped);
+    return array;
+};
+export const getCoinOjectIdsByAmount = async (address, amount, coinType) => {
+    let coinBalances = [];
+    let hasNextPage = true;
+    let nextCursor = undefined;
+    while (hasNextPage) {
+        try {
+            const coins = await getSuiClient().getCoins({
+                owner: address,
+                coinType,
+                cursor: nextCursor,
+            });
+            coinBalances = [...coinBalances, ...coins.data];
+            hasNextPage = coins.hasNextPage;
+            nextCursor = coins.nextCursor;
+        }
+        catch (error) {
+            console.error("Error fetching data:", error);
+            hasNextPage = false;
+        }
+    }
+    // sort coin balance before get object id
+    const coinObj = orderByKey(coinBalances.map((item) => {
+        return {
+            ...item,
+            balance: item.balance,
+        };
+    }), "balance", "desc");
+    let balance = "0";
+    const objectIds = [];
+    const objectCoins = [];
+    for (const coin of coinObj ?? []) {
+        balance = new BigNumber(coin.balance).plus(balance).toFixed();
+        objectIds.push(coin.coinObjectId);
+        objectCoins.push(coin);
+        if (new BigNumber(balance).isGreaterThanOrEqualTo(amount)) {
+            break;
+        }
+    }
+    return { objectIds, balance, objectCoins };
+};

package/lib/esm/libs/getSplitCoinForTx.js

@@ -0,0 +1,39 @@
+import { TransactionBlock, } from "@mysten/sui.js/transactions";
+import { getCoinOjectIdsByAmount } from "./getCoinOjectIdsByAmount";
+import BigNumber from "bignumber.js";
+import { SUI_TYPE } from "../constants/tokens";
+export const getSplitCoinForTx = async (account, amount, splits, coinType, inheritTx, inspecTransaction) => {
+    const tx = inheritTx ?? new TransactionBlock();
+    const { objectIds } = await getCoinOjectIdsByAmount(account, amount, coinType);
+    const coinObjectId = objectIds[0];
+    // TODO: find out why the tx.gas is limited at 950 sui
+    if (coinType === SUI_TYPE &&
+        new BigNumber(amount).lt(new BigNumber("950e9"))) {
+        const pureAmount = [];
+        for (const split of splits) {
+            pureAmount.push(tx.pure(split));
+        }
+        let coin;
+        if (inspecTransaction) {
+            if (objectIds.length > 1) {
+                tx.mergeCoins(tx.object(coinObjectId), objectIds.slice(1).map((item) => tx.object(item)));
+            }
+            coin = tx.splitCoins(tx.object(coinObjectId), pureAmount);
+        }
+        else {
+            coin = tx.splitCoins(tx.gas, pureAmount);
+        }
+        return { tx, coinData: coin };
+    }
+    if (objectIds.length > 1) {
+        tx.mergeCoins(tx.object(coinObjectId), objectIds.slice(1).map((item) => tx.object(item)));
+    }
+    //handle split coin
+    const pureAmount = [];
+    for (const split of splits) {
+        pureAmount.push(tx.pure(split));
+    }
+    // split correct amount to swap
+    const coinData = tx.splitCoins(tx.object(coinObjectId), pureAmount);
+    return { tx, coinData };
+};

package/lib/esm/libs/groupSwapRoutes.js

@@ -0,0 +1,58 @@
+import BigNumber from "bignumber.js";
+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 || new BigNumber(nextItem.amount).gt(0)) {
+            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

@@ -0,0 +1,37 @@
+import { BaseContract } from "../base";
+import { normalizeTokenType } from "../../../utils/token";
+const PACKAGE_ID = "0xc4049b2d1cc0f6e017fda8260e4377cecd236bd7f56a54fee120816e72e2e0dd";
+const MODULE_NAME = "swap";
+const POOL_REGISTRY = "0xfcc774493db2c45c79f688f88d28023a3e7d98e4ee9f48bbf5c7990f651577ae";
+const PROTOCOL_FEE_VAULT = "0xf194d9b1bcad972e45a7dd67dd49b3ee1e3357a00a50850c52cd51bb450e13b4";
+const TREASURY = "0x28e499dff5e864a2eafe476269a4f5035f1c16f338da7be18b103499abf271ce";
+const INSURANCE_FUND = "0xf0c40d67b078000e18032334c3325c47b9ec9f3d9ae4128be820d54663d14e3b";
+const REFERRAL_VAULT = "0x35d35b0e5b177593d8c3a801462485572fc30861e6ce96a55af6dc4730709278";
+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 [tokenOut] = tx.moveCall({
+            target: `${PACKAGE_ID}::${MODULE_NAME}::swap_exact_in`,
+            typeArguments: [lpCoinType, coinInType, coinOutType],
+            arguments: [
+                tx.object(poolId),
+                tx.object(POOL_REGISTRY),
+                tx.object(PROTOCOL_FEE_VAULT),
+                tx.object(TREASURY),
+                tx.object(INSURANCE_FUND),
+                tx.object(REFERRAL_VAULT),
+                inputCoinObject,
+                tx.pure(returnAmount),
+                tx.pure.u64("1000000000000000000"), // slippage
+            ],
+        });
+        return tokenOut;
+    }
+}

package/lib/esm/libs/protocols/base.js

@@ -0,0 +1,18 @@
+import { normalizeStructTag, parseStructTag } from "@mysten/sui.js/utils";
+import { SuiUtils } from "../../utils/sui";
+export class BaseContract {
+    swapInfo;
+    inputCoinObject;
+    currentAccount;
+    constructor({ swapInfo, inputCoinObject, currentAccount, }) {
+        this.swapInfo = swapInfo;
+        this.inputCoinObject = inputCoinObject;
+        this.currentAccount = currentAccount;
+    }
+    getInputCoinValue(tx) {
+        return SuiUtils.getCoinValue(this.swapInfo.assetIn, this.inputCoinObject, tx);
+    }
+    getTypeParams() {
+        return parseStructTag(this.swapInfo.extra?.poolStructTag || "").typeParams.map(normalizeStructTag);
+    }
+}

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

@@ -0,0 +1,21 @@
+import { BaseContract } from "../base";
+import { SuiUtils } from "../../../utils/sui";
+const PACKAGE_ID = "0xb24b6789e088b876afabca733bed2299fbc9e2d6369be4d1acfa17d8145454d9";
+const DEX_INFO_ID = "0x3f2d9f724f4a1ce5e71676448dc452be9a6243dac9c5b975a588c8c867066e92";
+export class BluemoveContract extends BaseContract {
+    async swap(tx) {
+        const [coinOut] = tx.moveCall({
+            target: `${PACKAGE_ID}::router::swap_exact_input_`,
+            typeArguments: [this.swapInfo.coinX.type, this.swapInfo.coinY.type],
+            arguments: [
+                SuiUtils.getCoinValue(this.swapInfo.swapXtoY
+                    ? this.swapInfo.coinX.type
+                    : this.swapInfo.coinY.type, this.inputCoinObject, tx), // input amount
+                this.inputCoinObject, // input coin
+                tx.pure.u64(0), // min output amount
+                tx.object(DEX_INFO_ID),
+            ],
+        });
+        return coinOut;
+    }
+}

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

@@ -0,0 +1,41 @@
+import { BaseContract } from "../base";
+import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui.js/utils";
+import { getDefaultSqrtPriceLimit } from "../utils";
+import { SuiUtils } from "../../../utils/sui";
+const GLOBAL_CONFIG_ID = "0xdaa46292632c3c4d8f31f23ea0f9b36a28ff3677e9684980e4438403a67a3d8f";
+const INTEGRATE_PACKAGE_ID = "0x6f5e582ede61fe5395b50c4a449ec11479a54d7ff8e0158247adfda60d98970b";
+export class CetusContract extends BaseContract {
+    async swap(tx) {
+        const sqrtPriceLimit = getDefaultSqrtPriceLimit(this.swapInfo.swapXtoY);
+        const typeArguments = [this.swapInfo.coinX.type, this.swapInfo.coinY.type];
+        const [zeroOut] = tx.moveCall({
+            target: "0x2::coin::zero",
+            typeArguments: [
+                this.swapInfo.swapXtoY
+                    ? this.swapInfo.coinY.type
+                    : this.swapInfo.coinX.type,
+            ],
+        });
+        const amountIn = SuiUtils.getCoinValue(this.swapInfo.swapXtoY
+            ? this.swapInfo.coinX.type
+            : this.swapInfo.coinY.type, this.inputCoinObject, tx);
+        const [receiveA, receiveB] = tx.moveCall({
+            target: `${INTEGRATE_PACKAGE_ID}::router::swap`,
+            typeArguments,
+            arguments: [
+                tx.object(GLOBAL_CONFIG_ID),
+                tx.object(this.swapInfo.poolId),
+                this.swapInfo.swapXtoY ? this.inputCoinObject : zeroOut, // coin A
+                this.swapInfo.swapXtoY ? zeroOut : this.inputCoinObject, // coin B
+                tx.pure(this.swapInfo.swapXtoY), // a to b or b to a
+                tx.pure(true), // exact in or out
+                amountIn, // swap amount
+                tx.pure.u128(sqrtPriceLimit.toString()), // sqrt price limit
+                tx.pure(false),
+                tx.object(SUI_CLOCK_OBJECT_ID),
+            ],
+        });
+        tx.transferObjects([this.swapInfo.swapXtoY ? receiveA : receiveB], tx.pure.address(this.currentAccount));
+        return this.swapInfo.swapXtoY ? receiveB : receiveA;
+    }
+}

package/lib/esm/libs/protocols/constants.js

@@ -0,0 +1,2 @@
+export const MIN_SQRT_PRICE = "4295048016";
+export const MAX_SQRT_PRICE = "79226673515401279992447579055";

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

@@ -0,0 +1,80 @@
+import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui.js/utils";
+import { BaseContract } from "../base";
+const PACKAGE_ID = "0xdee9";
+const MODULE_NAME = "clob_v2";
+const _7K_PACKAGE_ID = "0xd48e7cdc9e92bec69ce3baa75578010458a0c5b2733d661a84971e8cef6806bc";
+export class DeepBookContract extends BaseContract {
+    async swap(tx) {
+        const swapXtoY = this.swapInfo.swapXtoY;
+        const poolId = this.swapInfo.poolId;
+        const clientOrderId = Date.now();
+        const currentAddress = this.currentAccount;
+        const typeArgs = this.getTypeParams();
+        const lotSize = this.swapInfo.extra?.lotSize;
+        const [baseAsset, quoteAsset] = typeArgs;
+        const accountCap = this.createAccountCap(tx);
+        const amountIn = this.getInputCoinValue(tx);
+        let result;
+        if (swapXtoY) {
+            const amountInRound = tx.moveCall({
+                target: `${_7K_PACKAGE_ID}::math::m_round_down`,
+                arguments: [
+                    amountIn, // input coin value
+                    tx.pure.u64(lotSize), // lot size
+                ],
+            });
+            const [base_coin_ret, quote_coin_ret] = tx.moveCall({
+                target: `${PACKAGE_ID}::${MODULE_NAME}::swap_exact_base_for_quote`,
+                typeArguments: [baseAsset, quoteAsset],
+                arguments: [
+                    tx.object(poolId),
+                    tx.pure.u64(clientOrderId),
+                    accountCap,
+                    amountInRound,
+                    this.inputCoinObject, // coin 0 ~ base
+                    tx.moveCall({
+                        typeArguments: [quoteAsset],
+                        target: `0x2::coin::zero`,
+                        arguments: [],
+                    }), // coin 1 ~ quote
+                    tx.object(SUI_CLOCK_OBJECT_ID),
+                ],
+            });
+            this.deleteAccountCap(tx, accountCap);
+            tx.transferObjects([base_coin_ret], currentAddress);
+            result = quote_coin_ret;
+        }
+        else {
+            const [base_coin_ret, quote_coin_ret] = tx.moveCall({
+                target: `${PACKAGE_ID}::${MODULE_NAME}::swap_exact_quote_for_base`,
+                typeArguments: [baseAsset, quoteAsset],
+                arguments: [
+                    tx.object(poolId),
+                    tx.pure.u64(clientOrderId),
+                    accountCap,
+                    amountIn,
+                    tx.object(SUI_CLOCK_OBJECT_ID),
+                    this.inputCoinObject, // coin 1 ~ quote
+                ],
+            });
+            this.deleteAccountCap(tx, accountCap);
+            tx.transferObjects([quote_coin_ret], currentAddress);
+            result = base_coin_ret;
+        }
+        return result;
+    }
+    createAccountCap(tx) {
+        const [cap] = tx.moveCall({
+            typeArguments: [],
+            target: `${PACKAGE_ID}::${MODULE_NAME}::create_account`,
+            arguments: [],
+        });
+        return cap;
+    }
+    deleteAccountCap(tx, accountCap) {
+        tx.moveCall({
+            target: `${PACKAGE_ID}::custodian_v2::delete_account_cap`,
+            arguments: [accountCap],
+        });
+    }
+}

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

@@ -0,0 +1,16 @@
+import { BaseContract } from "../base";
+const PACKAGE_ID = "0xba153169476e8c3114962261d1edc70de5ad9781b83cc617ecc8c1923191cae0";
+const MODULE_NAME = "router";
+const CONTAINER_OBJECT_ID = "0xb65dcbf63fd3ad5d0ebfbf334780dc9f785eff38a4459e37ab08fa79576ee511";
+export class FlowXContract extends BaseContract {
+    async swap(tx) {
+        const coinInType = this.swapInfo.assetIn;
+        const coinOutType = this.swapInfo.assetOut;
+        const [tokenOut] = tx.moveCall({
+            target: `${PACKAGE_ID}::${MODULE_NAME}::swap_exact_input_direct`,
+            typeArguments: [coinInType, coinOutType],
+            arguments: [tx.object(CONTAINER_OBJECT_ID), this.inputCoinObject],
+        });
+        return tokenOut;
+    }
+}

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

@@ -0,0 +1,18 @@
+import { FlowXContract } from "./flowx";
+import { AfterMathContract } from "./aftermath";
+import { CetusContract } from "./cetus";
+import { DeepBookContract } from "./deepbook";
+import { KriyaContract } from "./kriya";
+import { TurbosContract } from "./turbos";
+import { SuiswapContract } from "./suiswap";
+import { BluemoveContract } from "./bluemove";
+export const ProtocolContract = {
+    cetus: CetusContract,
+    turbos: TurbosContract,
+    bluemove: BluemoveContract,
+    kriya: KriyaContract,
+    suiswap: SuiswapContract,
+    aftermath: AfterMathContract,
+    deepbook: DeepBookContract,
+    flowx: FlowXContract,
+};

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

@@ -0,0 +1,27 @@
+import { BaseContract } from "../base";
+import { normalizeTokenType } from "../../../utils/token";
+const PACKAGE_ID = "0xa0eba10b173538c8fecca1dff298e488402cc9ff374f8a12ca7758eebe830b66";
+const MODULE_NAME = "spot_dex";
+export class KriyaContract extends BaseContract {
+    async swap(tx) {
+        const swapXtoY = this.swapInfo.swapXtoY;
+        const coinInType = normalizeTokenType(this.swapInfo.assetIn);
+        const coinOutType = normalizeTokenType(this.swapInfo.assetOut);
+        const poolId = this.swapInfo.poolId;
+        const inputCoinObject = this.inputCoinObject;
+        const [tokenOut] = tx.moveCall({
+            target: `${PACKAGE_ID}::${MODULE_NAME}::${swapXtoY ? "swap_token_x" : "swap_token_y"}`,
+            typeArguments: [
+                swapXtoY ? coinInType : coinOutType,
+                swapXtoY ? coinOutType : coinInType,
+            ],
+            arguments: [
+                tx.object(poolId),
+                inputCoinObject,
+                this.getInputCoinValue(tx),
+                tx.pure.u64(0),
+            ],
+        });
+        return tokenOut;
+    }
+}

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

@@ -0,0 +1,30 @@
+import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui.js/utils";
+import { BaseContract } from "../base";
+const PACKAGE_ID = "0xd075d51486df71e750872b4edf82ea3409fda397ceecc0b6aedf573d923c54a0";
+const MODULE_NAME = "pool";
+export class SuiswapContract extends BaseContract {
+    async swap(tx) {
+        const poolId = this.swapInfo.poolId;
+        const swapXtoY = this.swapInfo.swapXtoY;
+        const inputCoin = this.inputCoinObject;
+        const typeArguments = [this.swapInfo.coinX.type, this.swapInfo.coinY.type];
+        const callFunc = swapXtoY
+            ? "do_swap_x_to_y_direct"
+            : "do_swap_y_to_x_direct";
+        const inputAmount = this.getInputCoinValue(tx);
+        const [tokenIn, tokenOut] = tx.moveCall({
+            target: `${PACKAGE_ID}::${MODULE_NAME}::${callFunc}`,
+            typeArguments,
+            arguments: [
+                tx.object(poolId),
+                tx.makeMoveVec({
+                    objects: [inputCoin],
+                }),
+                inputAmount,
+                tx.object(SUI_CLOCK_OBJECT_ID),
+            ],
+        });
+        tx.transferObjects([tokenIn], this.currentAccount);
+        return tokenOut;
+    }
+}

package/lib/esm/libs/protocols/turbos/constants.js

@@ -0,0 +1,4 @@
+export const MAX_TICK_STEP = 100;
+export const MAX_TICK_INDEX = 443636;
+export const MIN_TICK_INDEX = -443636;
+export const ONE_MINUTE = 60 * 1000;