@7kprotocol/sdk-ts 2.4.1 → 2.4.2-beta.1

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";
+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 && !isSponsored) {
+    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),

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

@@ -0,0 +1,29 @@
+import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils";
+import { BaseContract } from "../base";
+import { SuiUtils } from "../../../utils/sui";
+export class HaedalPMMContract extends BaseContract {
+    async swap(tx) {
+        const [coinX, coinY] = this.swapInfo.pool.allTokens;
+        const xToY = this.swapInfo.swapXtoY;
+        const { x_price_id, y_price_id } = this.swapInfo.extra || {};
+        if (!x_price_id || !y_price_id) {
+            throw new Error("x_price_id and y_price_id are required");
+        }
+        const config = this.config.haedal_pmm;
+        const [coinOut] = tx.moveCall({
+            target: `${config.package}::trader::${xToY ? "sell_base_coin" : "sell_quote_coin"}`,
+            typeArguments: [coinX.address, coinY.address],
+            arguments: [
+                tx.object(this.swapInfo.poolId),
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(x_price_id), // pyth pricefeed for x
+                tx.object(y_price_id), // pyth pricefeed for y
+                this.inputCoinObject, // mutable coin
+                this.getInputCoinValue(tx), // swap amount
+                tx.pure.u64(0), // min output amount
+            ],
+        });
+        SuiUtils.collectDust(tx, this.swapInfo.assetIn, this.inputCoinObject);
+        return coinOut;
+    }
+}

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

@@ -1,7 +1,6 @@
 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";
@@ -15,6 +14,9 @@ import { StSuiContract } from "./stsui";
 import { FlowxV3Contract } from "./flowxV3";
 import { SteammContract } from "./steamm";
 import { MagmaContract } from "./magma";
+import { HaedalPMMContract } from "./haedal_pmm";
+import { MomentumContract } from "./momentum";
+import { BluefinXContract } from "./bluefinx";
 export const ProtocolContract = {
     cetus: CetusContract,
     turbos: TurbosContract,
@@ -22,7 +24,6 @@ export const ProtocolContract = {
     kriya: KriyaContract,
     suiswap: SuiswapContract,
     aftermath: AfterMathContract,
-    deepbook: DeepBookContract,
     deepbook_v3: SponsoredDeepBookV3Contract,
     flowx: FlowXContract,
     flowx_v3: FlowxV3Contract,
@@ -32,5 +33,9 @@ export const ProtocolContract = {
     obric: ObricContract,
     stsui: StSuiContract,
     steamm: SteammContract,
+    steamm_oracle_quoter: SteammContract,
     magma: MagmaContract,
+    haedal_pmm: HaedalPMMContract,
+    momentum: MomentumContract,
+    bluefinx: BluefinXContract,
 };

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

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

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

@@ -0,0 +1,45 @@
+import { BaseContract } from "../base";
+import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils";
+import { getDefaultSqrtPriceLimit } from "../utils";
+import { SuiUtils } from "../../../utils/sui";
+export class MomentumContract extends BaseContract {
+    async swap(tx) {
+        const [coinX, coinY] = this.swapInfo.pool.allTokens;
+        const swapXtoY = this.swapInfo.swapXtoY;
+        const sqrtPriceLimit = getDefaultSqrtPriceLimit(swapXtoY);
+        const typeArguments = [coinX.address, coinY.address];
+        const { package: packageId, version } = this.config.momentum;
+        const [receiveA, receiveB, debt] = tx.moveCall({
+            target: `${packageId}::trade::flash_swap`,
+            typeArguments,
+            arguments: [
+                tx.object(this.swapInfo.poolId),
+                tx.pure.bool(swapXtoY), // a2b
+                tx.pure.bool(true), // exact in
+                this.getInputCoinValue(tx),
+                tx.pure.u128(sqrtPriceLimit.toString()), // sqrt price limit
+                tx.object(SUI_CLOCK_OBJECT_ID),
+                tx.object(version),
+            ],
+        });
+        tx.moveCall({
+            target: `${packageId}::trade::repay_flash_swap`,
+            typeArguments,
+            arguments: [
+                tx.object(this.swapInfo.poolId),
+                debt,
+                swapXtoY
+                    ? SuiUtils.coinIntoBalance(tx, coinX.address, this.inputCoinObject)
+                    : SuiUtils.zeroBalance(tx, coinX.address),
+                swapXtoY
+                    ? SuiUtils.zeroBalance(tx, coinY.address)
+                    : SuiUtils.coinIntoBalance(tx, coinY.address, this.inputCoinObject),
+                tx.object(version),
+            ],
+        });
+        const receiveACoin = SuiUtils.coinFromBalance(tx, coinX.address, receiveA);
+        const receiveBCoin = SuiUtils.coinFromBalance(tx, coinY.address, receiveB);
+        SuiUtils.collectDust(tx, this.swapInfo.assetIn, swapXtoY ? receiveACoin : receiveBCoin);
+        return swapXtoY ? receiveBCoin : receiveACoin;
+    }
+}