@7kprotocol/sdk-ts 2.4.0 → 2.4.2-beta.0

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

@@ -1,16 +1,28 @@
 import { Transaction, } from "@mysten/sui/transactions";
-import BigNumber from "bignumber.js";
+import { isValidSuiAddress, toBase64, toHex } from "@mysten/sui/utils";
+import { Config } from "../../config";
+import { _7K_CONFIG, _7K_PACKAGE_ID, _7K_VAULT } from "../../constants/_7k";
 import { getSplitCoinForTx } from "../../libs/getSplitCoinForTx";
 import { groupSwapRoutes } from "../../libs/groupSwapRoutes";
+import { sponsorBluefinX } from "../../libs/protocols/bluefinx/client";
+import { BluefinXTx } from "../../libs/protocols/bluefinx/types";
 import { swapWithRoute } from "../../libs/swapWithRoute";
-import { denormalizeTokenType } from "../../utils/token";
+import { isBluefinXRouting, } from "../../types/aggregator";
 import { SuiUtils } from "../../utils/sui";
-import { _7K_CONFIG, _7K_PACKAGE_ID, _7K_VAULT } from "../../constants/_7k";
-import { isValidSuiAddress } from "@mysten/sui/utils";
+import { denormalizeTokenType } from "../../utils/token";
 import { getConfig } from "./config";
-export const buildTx = async ({ quoteResponse, accountAddress, slippage, commission: _commission, devInspect, extendTx, }) => {
+export const buildTx = async ({ quoteResponse, accountAddress, slippage, commission: __commission, devInspect, extendTx, isSponsored, }) => {
+    const isBluefinX = isBluefinXRouting(quoteResponse);
+    const _commission = {
+        ...__commission,
+        // commission is ignored for bluefinx
+        commissionBps: isBluefinX ? 0 : __commission.commissionBps,
+    };
     const { tx: _tx, 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");
     }
@@ -26,12 +38,13 @@ export const buildTx = async ({ quoteResponse, accountAddress, slippage, commiss
     let coinData;
     if (coinIn) {
         coinData = tx.splitCoins(coinIn, splits);
-        SuiUtils.transferOrDestroyZeroCoin(tx, quoteResponse.tokenIn, coinIn, accountAddress);
+        SuiUtils.collectDust(tx, quoteResponse.tokenIn, coinIn);
     }
     else {
-        const { coinData: _data } = await getSplitCoinForTx(accountAddress, quoteResponse.swapAmountWithDecimal, splits, denormalizeTokenType(quoteResponse.tokenIn), tx, devInspect);
+        const { coinData: _data } = await getSplitCoinForTx(accountAddress, quoteResponse.swapAmountWithDecimal, splits, denormalizeTokenType(quoteResponse.tokenIn), tx, devInspect, isSponsored || isBluefinX);
         coinData = _data;
     }
+    const pythMap = await updatePythPriceFeedsIfAny(tx, quoteResponse);
     const coinObjects = [];
     const config = await getConfig();
     await Promise.all(routes.map(async (route, index) => {
@@ -42,6 +55,7 @@ export const buildTx = async ({ quoteResponse, accountAddress, slippage, commiss
             currentAccount: accountAddress,
             tx,
             config,
+            pythMap,
         });
         if (coinRes) {
             coinObjects.push(coinRes);
@@ -51,16 +65,11 @@ export const buildTx = async ({ quoteResponse, accountAddress, slippage, commiss
         const mergeCoin = coinObjects.length > 1
             ? SuiUtils.mergeCoins(coinObjects, tx)
             : coinObjects[0];
-        coinOut = mergeCoin;
-        const minReceived = new BigNumber(1)
-            .minus(slippage)
-            .multipliedBy(quoteResponse.returnAmountWithDecimal)
-            .toFixed(0);
-        const [partner] = tx.moveCall({
-            target: "0x1::option::some",
-            typeArguments: [`address`],
-            arguments: [tx.pure.address(_commission.partner)],
-        });
+        const returnAmountAfterCommission = (BigInt(10000 - _commission.commissionBps) *
+            BigInt(quoteResponse.returnAmountWithDecimal)) /
+            BigInt(10000);
+        const minReceived = (BigInt(1e9 - +slippage * 1e9) * BigInt(returnAmountAfterCommission)) /
+            BigInt(1e9);
         tx.moveCall({
             target: `${_7K_PACKAGE_ID}::settle::settle`,
             typeArguments: [quoteResponse.tokenIn, quoteResponse.tokenOut],
@@ -69,15 +78,67 @@ export const buildTx = async ({ quoteResponse, accountAddress, slippage, commiss
                 tx.object(_7K_VAULT),
                 tx.pure.u64(quoteResponse.swapAmountWithDecimal),
                 mergeCoin,
-                tx.pure.u64(minReceived),
-                tx.pure.u64(quoteResponse.returnAmountWithDecimal),
-                partner,
+                tx.pure.u64(minReceived), // minimum received
+                tx.pure.u64(returnAmountAfterCommission), // expected amount out
+                tx.pure.option("address", isValidSuiAddress(_commission.partner) ? _commission.partner : null),
                 tx.pure.u64(_commission.commissionBps),
+                tx.pure.u64(0),
             ],
         });
         if (!extendTx) {
             tx.transferObjects([mergeCoin], tx.pure.address(accountAddress));
         }
+        else {
+            coinOut = mergeCoin;
+        }
+    }
+    if (isBluefinX) {
+        const extra = quoteResponse.swaps[0].extra;
+        if (extra.quoteExpiresAtUtcMillis < Date.now()) {
+            throw new Error("Quote expired");
+        }
+        tx.setSenderIfNotSet(accountAddress);
+        const bytes = await tx.build({
+            client: Config.getSuiClient(),
+            onlyTransactionKind: true,
+        });
+        const res = await sponsorBluefinX({
+            quoteId: extra.quoteId,
+            txBytes: toBase64(bytes),
+            sender: accountAddress,
+        });
+        if (!res.success) {
+            throw new Error("Sponsor failed");
+        }
+        return {
+            tx: new BluefinXTx(res.quoteId, res.data.txBytes),
+            coinOut,
+        };
     }
     return { tx, coinOut };
 };
+const getPythPriceFeeds = (res) => {
+    const ids = [];
+    for (const s of res.swaps) {
+        for (const o of s.extra?.oracles || []) {
+            const bytes = o.Pyth?.price_identifier?.bytes;
+            if (bytes) {
+                ids.push("0x" + toHex(Uint8Array.from(bytes)));
+            }
+        }
+    }
+    return ids;
+};
+const updatePythPriceFeedsIfAny = async (tx, quoteResponse) => {
+    // update oracles price if any
+    const pythMap = {};
+    const pythIds = getPythPriceFeeds(quoteResponse);
+    if (pythIds.length > 0) {
+        const prices = await Config.getPythConnection().getPriceFeedsUpdateData(pythIds);
+        const ids = await Config.getPythClient().updatePriceFeeds(tx, prices, pythIds);
+        pythIds.map((id, index) => {
+            pythMap[id] = ids[index];
+        });
+    }
+    return pythMap;
+};

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

@@ -1,7 +1,5 @@
 import { fetchClient } from "../../config/fetchClient";
 import { API_ENDPOINTS } from "../../constants/apiEndpoints";
-let config = null;
-let configTs = 0;
 export const DEFAULT_CONFIG = {
     aftermath: {
         name: "Aftermath",
@@ -17,6 +15,11 @@ export const DEFAULT_CONFIG = {
         package: "0x6c796c3ab3421a68158e0df18e4657b2827b1f8fed5ed4b82dba9c935988711b",
         globalConfig: "0x03db251ba509a8d5d8777b6338836082335d93eecbdd09a11e190a1cff51c352",
     },
+    bluefinx: {
+        name: "BluefinX",
+        package: "0xf8870f988ab09be7c5820a856bd5e9da84fc7192e095a7a8829919293b00a36c",
+        globalConfig: "0xc6b29a60c3924776bedc78df72c127ea52b86aeb655432979a38f13d742dedaa",
+    },
     bluemove: {
         name: "Bluemove",
         package: "0x08cd33481587d4c4612865b164796d937df13747d8c763b8a178c87e3244498f",
@@ -27,10 +30,6 @@ export const DEFAULT_CONFIG = {
         package: "0x6f5e582ede61fe5395b50c4a449ec11479a54d7ff8e0158247adfda60d98970b",
         globalConfig: "0xdaa46292632c3c4d8f31f23ea0f9b36a28ff3677e9684980e4438403a67a3d8f",
     },
-    deepbook: {
-        name: "Deepbook",
-        package: "0xdee9",
-    },
     deepbook_v3: {
         name: "Deepbook V3",
         package: "",
@@ -83,13 +82,25 @@ export const DEFAULT_CONFIG = {
         name: "Steamm",
         package: "0x4fb1cf45dffd6230305f1d269dd1816678cc8e3ba0b747a813a556921219f261",
         script: "0x13bfc09cfc1bd922d3aa53fcf7b2cd510727ee65068ce136e2ebd5f3b213fdd2",
+        oracle: "0xe84b649199654d18c38e727212f5d8dacfc3cf78d60d0a7fc85fd589f280eb2b",
     },
     magma: {
         name: "Magma",
         package: "0x951d48bece7f6c2a3f4ba0b5791ba823c491e504feb4136497ee51331208ac33",
         globalConfig: "0x4c4e1402401f72c7d8533d0ed8d5f8949da363c7a3319ccef261ffe153d32f8a",
     },
+    haedal_pmm: {
+        name: "Haedal PMM",
+        package: "0xa0e3b011012b80af4957afa30e556486eb3da0a7d96eeb733cf16ccd3aec32e0",
+    },
+    momentum: {
+        name: "Momentum",
+        package: "0x70285592c97965e811e0c6f98dccc3a9c2b4ad854b3594faab9597ada267b860",
+        version: "0x2375a0b1ec12010aaea3b2545acfa2ad34cfbba03ce4b59f4c39e1e25eed1b2a",
+    },
 };
+let config = DEFAULT_CONFIG;
+let configTs = 0;
 export async function getConfig() {
     const ttl = 60;
     if (config && Date.now() - configTs < ttl * 1000) {
@@ -98,9 +109,9 @@ export async function getConfig() {
     try {
         const response = await fetchClient(`${API_ENDPOINTS.MAIN}/config`);
         const quoteResponse = (await response.json());
-        config = quoteResponse;
+        config = { ...config, ...quoteResponse };
         configTs = Date.now();
-        return quoteResponse;
+        return config;
     }
     catch (_) {
         return DEFAULT_CONFIG;

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

@@ -1,12 +1,16 @@
-import BigNumber from "bignumber.js";
 import { SUI_DECIMALS } from "@mysten/sui/utils";
-import { buildTx } from "./buildTx";
+import { Config } from "../../config";
+import { isBluefinXRouting } from "../../types/aggregator";
 import { formatBalance } from "../../utils/number";
 import { getSuiPrice } from "../prices";
-import { Config } from "../../config";
+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,
@@ -19,7 +23,7 @@ export async function estimateGasFee({ quoteResponse, accountAddress, slippage,
         return undefined;
     });
     const { tx } = result || {};
-    if (!tx)
+    if (!tx || tx instanceof BluefinXTx)
         return 0;
     const suiPrice = _suiPrice || (await getSuiPrice());
     const suiDecimals = SUI_DECIMALS;
@@ -29,9 +33,9 @@ export async function estimateGasFee({ quoteResponse, accountAddress, slippage,
     });
     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();
+    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

@@ -0,0 +1,48 @@
+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,6 +1,7 @@
 import { normalizeStructTag, normalizeSuiObjectId } from "@mysten/sui/utils";
-import { API_ENDPOINTS } from "../../constants/apiEndpoints";
 import { fetchClient } from "../../config/fetchClient";
+import { API_ENDPOINTS } from "../../constants/apiEndpoints";
+import { isBluefinXRouting } from "../../types/aggregator";
 export const DEFAULT_SOURCES = [
     "suiswap",
     "turbos",
@@ -9,7 +10,6 @@ export const DEFAULT_SOURCES = [
     "kriya",
     "kriya_v3",
     "aftermath",
-    "deepbook",
     "deepbook_v3",
     "flowx",
     "flowx_v3",
@@ -18,9 +18,12 @@ export const DEFAULT_SOURCES = [
     "obric",
     "stsui",
     "steamm",
+    "steamm_oracle_quoter",
     "magma",
+    "haedal_pmm",
+    "momentum",
 ];
-export async function getQuote({ tokenIn, tokenOut, amountIn, sources = DEFAULT_SOURCES, targetPools, excludedPools, }) {
+export async function getQuote({ tokenIn, tokenOut, amountIn, sources = DEFAULT_SOURCES, commissionBps, targetPools, excludedPools, taker, }) {
     const params = new URLSearchParams({
         amount: amountIn,
         from: normalizeStructTag(tokenIn),
@@ -33,10 +36,28 @@ export async function getQuote({ tokenIn, tokenOut, amountIn, sources = DEFAULT_
     if (excludedPools?.length) {
         params.append("excluded_pools", excludedPools.map((v) => normalizeSuiObjectId(v)).join(","));
     }
+    if (taker) {
+        params.append("taker", taker);
+    }
     const response = await fetchClient(`${API_ENDPOINTS.MAIN}/quote?${params}`);
     if (!response.ok) {
         throw new Error("Failed to fetch aggregator quote");
     }
     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/index.js

@@ -1,4 +1,5 @@
 export * from "./buildTx";
 export * from "./estimateGasFee";
+export * from "./executeTx";
 export * from "./getQuote";
 export * from "./getSwapHistory";

package/lib/esm/index.mjs

@@ -1,8 +1,9 @@
 export * from "./types/aggregator";
 import { Config } from "./config";
-import { getTokenPrice, getTokenPrices, getSuiPrice } from "./features/prices";
-import { buildTx, getQuote, estimateGasFee, getSwapHistory, } from "./features/swap";
-import { placeLimitOrder, getOpenLimitOrders, cancelLimitOrder, claimExpiredLimitOrder, getClosedLimitOrders, placeDcaOrder, getOpenDcaOrders, cancelDcaOrder, getClosedDcaOrders, getDcaOrderExecutions, } from "./features/limitDca";
+import { getSuiPrice, getTokenPrice, getTokenPrices } from "./features/prices";
+import { executeBluefinTx } from "./libs/protocols/bluefinx/client";
+import { buildTx, estimateGasFee, executeTx, getQuote, getSwapHistory, DEFAULT_SOURCES, } from "./features/swap";
+import { cancelDcaOrder, cancelLimitOrder, claimExpiredLimitOrder, getClosedDcaOrders, getClosedLimitOrders, getDcaOrderExecutions, getOpenDcaOrders, getOpenLimitOrders, placeDcaOrder, placeLimitOrder, } from "./features/limitDca";
 // avoid breaking changes
 const getSuiClient = Config.getSuiClient;
 const setSuiClient = Config.setSuiClient;
@@ -14,7 +15,7 @@ getSuiClient, setSuiClient,
 // prices
 getTokenPrice, getTokenPrices, getSuiPrice, 
 // swap
-getQuote, estimateGasFee, buildTx, getSwapHistory, 
+getQuote, estimateGasFee, buildTx, getSwapHistory, executeTx, executeBluefinTx, DEFAULT_SOURCES, 
 // limit order
 placeLimitOrder, getOpenLimitOrders, cancelLimitOrder, claimExpiredLimitOrder, getClosedLimitOrders, 
 // dca
@@ -34,6 +35,9 @@ export default {
     estimateGasFee,
     buildTx,
     getSwapHistory,
+    executeTx,
+    executeBluefinTx,
+    DEFAULT_SOURCES,
     // limit order
     placeLimitOrder,
     getOpenLimitOrders,

package/lib/esm/libs/getCoinOjectIdsByAmount.js

@@ -1,15 +1,15 @@
-import BigNumber from "bignumber.js";
 import { Config } from "../config";
 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 a = BigInt(array[i][key]);
+            const b = BigInt(array[i + 1][key]);
+            if (sortBy === "desc" ? a < b : a > b) {
                 const temp = array[i];
                 array[i] = array[i + 1];
                 array[i + 1] = temp;
@@ -45,15 +45,15 @@ export const getCoinOjectIdsByAmount = async (address, amount, coinType) => {
             ...item,
             balance: item.balance,
         };
-    }), "balance", "desc");
+    }), "balance", "desc") ?? [];
     let balance = "0";
     const objectIds = [];
     const objectCoins = [];
-    for (const coin of coinObj ?? []) {
-        balance = new BigNumber(coin.balance).plus(balance).toFixed();
+    for (const coin of coinObj) {
+        balance = (BigInt(coin.balance) + BigInt(balance)).toString(10);
         objectIds.push(coin.coinObjectId);
         objectCoins.push(coin);
-        if (new BigNumber(balance).isGreaterThanOrEqualTo(amount)) {
+        if (BigInt(balance) >= BigInt(amount)) {
             break;
         }
     }

package/lib/esm/libs/getSplitCoinForTx.js

@@ -1,11 +1,13 @@
 import { Transaction } from "@mysten/sui/transactions";
-import { getCoinOjectIdsByAmount } from "./getCoinOjectIdsByAmount";
+import { normalizeStructTag } from "@mysten/sui/utils";
 import { SUI_TYPE } from "../constants/tokens";
-export const getSplitCoinForTx = async (account, amount, splits, coinType, inheritTx, inspecTransaction) => {
+import { getCoinOjectIdsByAmount } from "./getCoinOjectIdsByAmount";
+export const getSplitCoinForTx = async (account, amount, splits, coinType, inheritTx, inspecTransaction, isSponsored = false) => {
     const tx = inheritTx ?? new Transaction();
     const { objectIds } = await getCoinOjectIdsByAmount(account, amount, coinType);
     const coinObjectId = objectIds[0];
-    if (coinType === SUI_TYPE) {
+    if (normalizeStructTag(coinType) === normalizeStructTag(SUI_TYPE) &&
+        !isSponsored) {
         let coin;
         if (inspecTransaction) {
             if (objectIds.length > 1) {

package/lib/esm/libs/groupSwapRoutes.js

@@ -1,4 +1,3 @@
-import BigNumber from "bignumber.js";
 import { denormalizeTokenType } from "../utils/token";
 export function groupSwapRoutes(quoteResponse) {
     if (!quoteResponse.routes || !quoteResponse.swaps) {
@@ -12,7 +11,7 @@ export function groupSwapRoutes(quoteResponse) {
         const item = items[i];
         currentGroup.push(item);
         const nextItem = items[i + 1];
-        if (!nextItem || new BigNumber(nextItem.amount).gt(0)) {
+        if (!nextItem || BigInt(nextItem.amount) > 0n) {
             groupedItems.push(currentGroup);
             currentGroup = [];
         }

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

@@ -5,11 +5,13 @@ export class BaseContract {
     inputCoinObject;
     currentAccount;
     config;
-    constructor({ swapInfo, inputCoinObject, currentAccount, config, }) {
+    pythMap;
+    constructor({ swapInfo, inputCoinObject, currentAccount, config, pythMap, }) {
         this.swapInfo = swapInfo;
         this.inputCoinObject = inputCoinObject;
         this.currentAccount = currentAccount;
         this.config = config;
+        this.pythMap = pythMap;
     }
     getInputCoinValue(tx) {
         return SuiUtils.getCoinValue(this.swapInfo.assetIn, this.inputCoinObject, tx);
@@ -17,4 +19,11 @@ export class BaseContract {
     getTypeParams() {
         return parseStructTag(this.swapInfo.extra?.poolStructTag || "").typeParams.map(normalizeStructTag);
     }
+    get extra() {
+        const extra = this.swapInfo.extra;
+        if (!extra) {
+            throw new Error(`Invalid extra info for getExtra`);
+        }
+        return extra;
+    }
 }

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

@@ -1,7 +1,6 @@
 import { BaseContract } from "../base";
 import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils";
 import { getDefaultSqrtPriceLimit } from "../utils";
-import BN from "bn.js";
 import { SuiUtils } from "../../../utils/sui";
 export class BluefinContract extends BaseContract {
     async swap(tx) {
@@ -24,14 +23,12 @@ export class BluefinContract extends BaseContract {
                 tx.pure.bool(true),
                 amountIn,
                 tx.pure.u64(0),
-                tx.pure.u128(getDefaultSqrtPriceLimit(swapXtoY)
-                    .add(swapXtoY ? new BN(1) : new BN(-1))
-                    .toString(10)),
+                tx.pure.u128(getDefaultSqrtPriceLimit(swapXtoY) + (swapXtoY ? 1n : -1n)),
             ],
         });
         const coinOutX = SuiUtils.coinFromBalance(tx, coinX.address, balanceOutX);
         const coinOutY = SuiUtils.coinFromBalance(tx, coinY.address, balanceOutY);
-        SuiUtils.transferOrDestroyZeroCoin(tx, this.swapInfo.assetIn, swapXtoY ? coinOutX : coinOutY, this.currentAccount);
+        SuiUtils.collectDust(tx, this.swapInfo.assetIn, swapXtoY ? coinOutX : coinOutY);
         return swapXtoY ? coinOutY : coinOutX;
     }
 }

package/lib/esm/libs/protocols/bluefinx/client.js

@@ -0,0 +1,30 @@
+import { API_ENDPOINTS } from "../../../constants/apiEndpoints";
+const request = async (path, body) => {
+    const res = await fetch(`${API_ENDPOINTS.MAIN}/${path}`, {
+        method: "POST",
+        body: JSON.stringify(body),
+        headers: {
+            "Content-Type": "application/json",
+        },
+    });
+    return res.json();
+};
+export const sponsorBluefinX = async (body) => {
+    return await request("bluefinx/sponsor", body);
+};
+/**
+ * Request BluefinX for signing sponsored tx and execute it
+ *
+ * @Warning
+ * User must use this function to execute BluefinX tx, otherwise the tx will be rejected by BluefinX contract
+ * @param tx - BluefinX tx which is generated by `buildTx`
+ * @param signature - user signature after signing the transaction
+ * @returns `SwapResponse`
+ */
+export const executeBluefinTx = async (tx, signature) => {
+    return await request("bluefinx/swap", {
+        quoteId: tx.quoteId,
+        txBytes: tx.txBytes,
+        signature,
+    });
+};

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

@@ -0,0 +1,44 @@
+import { bcs } from "@mysten/sui/bcs";
+import { fromBase64, normalizeStructTag, SUI_CLOCK_OBJECT_ID, } from "@mysten/sui/utils";
+import { SuiUtils } from "../../../utils/sui";
+import { BaseContract } from "../base";
+const BcsQuote = bcs.struct("Quote", {
+    vault: bcs.Address,
+    id: bcs.string(),
+    taker: bcs.Address,
+    token_in_amount: bcs.u64(),
+    token_out_amount: bcs.u64(),
+    token_in_type: bcs.string(),
+    token_out_type: bcs.string(),
+    expires_at: bcs.u64(),
+    created_at: bcs.u64(),
+});
+export class BluefinXContract extends BaseContract {
+    async swap(tx) {
+        const extra = this.extra;
+        const quoteBytes = BcsQuote.serialize({
+            vault: extra.vault,
+            id: extra.quoteId,
+            taker: extra.taker,
+            token_in_amount: this.swapInfo.amount,
+            token_out_amount: this.swapInfo.returnAmount,
+            token_in_type: normalizeStructTag(this.swapInfo.assetIn).slice(2),
+            token_out_type: normalizeStructTag(this.swapInfo.assetOut).slice(2),
+            expires_at: extra.quoteExpiresAtUtcMillis,
+            created_at: extra.createdAtUtcMillis,
+        }).toBytes();
+        const [out] = tx.moveCall({
+            arguments: [
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(extra.vault),
+                tx.object(this.config.bluefinx.globalConfig),
+                tx.pure.vector("u8", Array.from(quoteBytes)),
+                tx.pure.vector("u8", Array.from(fromBase64(extra.signature))),
+                SuiUtils.coinIntoBalance(tx, this.swapInfo.assetIn, this.inputCoinObject),
+            ],
+            target: `${this.config.bluefinx.package}::vault::swap`,
+            typeArguments: [this.swapInfo.assetIn, this.swapInfo.assetOut],
+        });
+        return SuiUtils.coinFromBalance(tx, this.swapInfo.assetOut, out);
+    }
+}

package/lib/esm/libs/protocols/bluefinx/types.js

@@ -0,0 +1,8 @@
+export class BluefinXTx {
+    quoteId;
+    txBytes;
+    constructor(quoteId, txBytes) {
+        this.quoteId = quoteId;
+        this.txBytes = txBytes;
+    }
+}

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

@@ -34,7 +34,7 @@ export class CetusContract extends BaseContract {
                 tx.object(SUI_CLOCK_OBJECT_ID),
             ],
         });
-        SuiUtils.transferOrDestroyZeroCoin(tx, this.swapInfo.assetIn, this.swapInfo.swapXtoY ? receiveA : receiveB, this.currentAccount);
+        SuiUtils.collectDust(tx, this.swapInfo.assetIn, this.swapInfo.swapXtoY ? receiveA : receiveB);
         return this.swapInfo.swapXtoY ? receiveB : receiveA;
     }
 }

package/lib/esm/libs/protocols/deepbookV3/sponsored.js

@@ -20,7 +20,7 @@ export class SponsoredDeepBookV3Contract extends BaseContract {
         });
         const coinIn = swapXtoY ? base : quote;
         const coinOut = swapXtoY ? quote : base;
-        SuiUtils.transferOrDestroyZeroCoin(tx, this.swapInfo.assetIn, coinIn, this.currentAccount);
+        SuiUtils.collectDust(tx, this.swapInfo.assetIn, coinIn);
         return coinOut;
     }
 }

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

@@ -1,7 +1,6 @@
 import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils";
 import { BaseContract } from "../base";
 import { getDefaultSqrtPriceLimit } from "../utils";
-import { BN } from "bn.js";
 export class FlowxV3Contract extends BaseContract {
     async swap(tx) {
         const [coinX, coinY] = this.swapInfo.pool.allTokens;
@@ -22,9 +21,7 @@ export class FlowxV3Contract extends BaseContract {
                 tx.pure.u64(swapFeeRate), // swap fee rate to lookup pool in the registry
                 this.inputCoinObject,
                 tx.pure.u64(0), // min amount out
-                tx.pure.u128(getDefaultSqrtPriceLimit(swapXtoY)
-                    .add(swapXtoY ? new BN(1) : new BN(-1))
-                    .toString(10)), // sqrt price limit
+                tx.pure.u128(getDefaultSqrtPriceLimit(swapXtoY) + (swapXtoY ? 1n : -1n)), // sqrt price limit
                 tx.pure.u64("18446744073709551615"), // u64 max value
                 tx.object(config.version),
                 tx.object(SUI_CLOCK_OBJECT_ID),