@shapeshiftoss/swapper 17.6.6-alpha.1 → 17.6.7

package/dist/esm/constants.js

@@ -5,6 +5,8 @@ import { bebopSwapper } from './swappers/BebopSwapper/BebopSwapper.js';
 import { bebopApi } from './swappers/BebopSwapper/endpoints.js';
 import { butterSwap } from './swappers/ButterSwap/ButterSwap.js';
 import { butterSwapApi } from './swappers/ButterSwap/endpoints.js';
+import { cetusSwapper } from './swappers/CetusSwapper/CetusSwapper.js';
+import { cetusApi } from './swappers/CetusSwapper/endpoints.js';
 import { chainflipSwapper } from './swappers/ChainflipSwapper/ChainflipSwapper.js';
 import { chainflipApi } from './swappers/ChainflipSwapper/endpoints.js';
 import { cowSwapper } from './swappers/CowSwapper/CowSwapper.js';
@@ -81,6 +83,10 @@ export const swappers = {
         ...nearIntentsSwapper,
         ...nearIntentsApi,
     },
+    [SwapperName.Cetus]: {
+        ...cetusSwapper,
+        ...cetusApi,
+    },
     [SwapperName.Test]: undefined,
 };
 // Slippage defaults. Don't export these to ensure the getDefaultSlippageDecimalPercentageForSwapper helper function is used.
@@ -93,6 +99,7 @@ const DEFAULT_MAYA_SLIPPAGE_DECIMAL_PERCENTAGE = '0.01'; // 1%
 const DEFAULT_ARBITRUM_BRIDGE_SLIPPAGE_DECIMAL_PERCENTAGE = '0'; // no slippage for Arbitrum Bridge, so no slippage tolerance
 const DEFAULT_CHAINFLIP_SLIPPAGE_DECIMAL_PERCENTAGE = '0.02'; // 2%
 const DEFAULT_BUTTERSWAP_SLIPPAGE_DECIMAL_PERCENTAGE = '0.015'; // 1.5%
+const DEFAULT_CETUS_SLIPPAGE_DECIMAL_PERCENTAGE = '0.005'; // .5%
 export const getDefaultSlippageDecimalPercentageForSwapper = (swapperName) => {
     if (swapperName === undefined)
         return DEFAULT_SLIPPAGE_DECIMAL_PERCENTAGE;
@@ -121,6 +128,8 @@ export const getDefaultSlippageDecimalPercentageForSwapper = (swapperName) => {
             return DEFAULT_BUTTERSWAP_SLIPPAGE_DECIMAL_PERCENTAGE;
         case SwapperName.NearIntents:
             return DEFAULT_NEAR_INTENTS_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case SwapperName.Cetus:
+            return DEFAULT_CETUS_SLIPPAGE_DECIMAL_PERCENTAGE;
         default:
             return assertUnreachable(swapperName);
     }

package/dist/esm/index.d.ts

@@ -4,6 +4,7 @@ export * from './safe-utils/index.js';
 export * from './swapper.js';
 export * from './swappers/ArbitrumBridgeSwapper/index.js';
 export * from './swappers/BebopSwapper/index.js';
+export * from './swappers/CetusSwapper/index.js';
 export * from './swappers/ChainflipSwapper/index.js';
 export * from './swappers/CowSwapper/index.js';
 export * from './swappers/JupiterSwapper/index.js';

package/dist/esm/index.js

@@ -4,6 +4,7 @@ export * from './safe-utils/index.js';
 export * from './swapper.js';
 export * from './swappers/ArbitrumBridgeSwapper/index.js';
 export * from './swappers/BebopSwapper/index.js';
+export * from './swappers/CetusSwapper/index.js';
 export * from './swappers/ChainflipSwapper/index.js';
 export * from './swappers/CowSwapper/index.js';
 export * from './swappers/JupiterSwapper/index.js';

package/dist/esm/swappers/ButterSwap/swapperApi/getTradeQuote.test.js

@@ -30,6 +30,8 @@ describe('getTradeQuote', () => {
             assertGetUtxoChainAdapter: () => vi.fn(),
             assertGetCosmosSdkChainAdapter: () => vi.fn(),
             assertGetSolanaChainAdapter: () => vi.fn(),
+            assertGetTronChainAdapter: () => vi.fn(),
+            assertGetSuiChainAdapter: () => vi.fn(),
             config: {
                 VITE_BUTTERSWAP_CLIENT_ID: 'test',
             },

package/dist/esm/swappers/ButterSwap/swapperApi/getTradeRate.test.js

@@ -21,6 +21,8 @@ describe('getTradeRate', () => {
             assertGetUtxoChainAdapter: () => vi.fn(),
             assertGetCosmosSdkChainAdapter: () => vi.fn(),
             assertGetSolanaChainAdapter: () => vi.fn(),
+            assertGetTronChainAdapter: () => vi.fn(),
+            assertGetSuiChainAdapter: () => vi.fn(),
             config: {
                 VITE_BUTTERSWAP_CLIENT_ID: 'test',
             },
@@ -53,6 +55,8 @@ describe('getTradeRate', () => {
             assertGetUtxoChainAdapter: () => vi.fn(),
             assertGetCosmosSdkChainAdapter: () => vi.fn(),
             assertGetSolanaChainAdapter: () => vi.fn(),
+            assertGetTronChainAdapter: () => vi.fn(),
+            assertGetSuiChainAdapter: () => vi.fn(),
             config: {
                 VITE_BUTTERSWAP_CLIENT_ID: 'test',
             },

package/dist/esm/swappers/CetusSwapper/CetusSwapper.d.ts

@@ -0,0 +1,2 @@
+import type { Swapper } from '../../types.js';
+export declare const cetusSwapper: Swapper;

package/dist/esm/swappers/CetusSwapper/CetusSwapper.js

@@ -0,0 +1,4 @@
+import { executeSuiTransaction } from '../../index.js';
+export const cetusSwapper = {
+    executeSuiTransaction,
+};

package/dist/esm/swappers/CetusSwapper/endpoints.d.ts

@@ -0,0 +1,2 @@
+import type { SwapperApi } from '../../types.js';
+export declare const cetusApi: SwapperApi;

package/dist/esm/swappers/CetusSwapper/endpoints.js

@@ -0,0 +1,84 @@
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import { checkSuiSwapStatus, getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { getTradeQuote } from './swapperApi/getTradeQuote.js';
+import { getTradeRate } from './swapperApi/getTradeRate.js';
+import { calculateAmountLimit, calculateSwapAmounts, determineSwapDirection, findBestPool, getCetusSDK, getCoinType, } from './utils/helpers.js';
+export const cetusApi = {
+    getTradeQuote: (input, deps) => {
+        return getTradeQuote(input, deps);
+    },
+    getTradeRate: (input, deps) => {
+        return getTradeRate(input, deps);
+    },
+    getUnsignedSuiTransaction: async ({ stepIndex, tradeQuote, from, assertGetSuiChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { accountNumber, sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = step;
+        const adapter = assertGetSuiChainAdapter(sellAsset.chainId);
+        const sdk = await getCetusSDK();
+        sdk.senderAddress = from;
+        const sellCoinType = getCoinType(sellAsset);
+        const buyCoinType = getCoinType(buyAsset);
+        const pool = await findBestPool(sdk, sellCoinType, buyCoinType);
+        if (!pool) {
+            throw new Error(`No liquidity pool found for ${sellAsset.symbol}/${buyAsset.symbol}`);
+        }
+        const swapResult = await calculateSwapAmounts(sdk, pool, sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit);
+        if (!swapResult) {
+            throw new Error(`Failed to calculate swap for ${sellAsset.symbol}/${buyAsset.symbol}`);
+        }
+        const a2b = determineSwapDirection(pool, sellCoinType, buyCoinType);
+        const amountLimit = calculateAmountLimit(swapResult.estimatedAmountOut, tradeQuote.slippageTolerancePercentageDecimal, true);
+        const tx = await sdk.Swap.createSwapTransactionPayload({
+            pool_id: pool.poolAddress,
+            coinTypeA: pool.coinTypeA,
+            coinTypeB: pool.coinTypeB,
+            a2b,
+            by_amount_in: true,
+            amount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            amount_limit: amountLimit,
+        });
+        const transactionBytes = await tx.build({ client: adapter.getSuiClient() });
+        const intentMessage = new Uint8Array(3 + transactionBytes.length);
+        intentMessage[0] = 0;
+        intentMessage[1] = 0;
+        intentMessage[2] = 0;
+        intentMessage.set(transactionBytes, 3);
+        const bip44Params = adapter.getBip44Params({ accountNumber });
+        const addressNList = [
+            bip44Params.purpose,
+            bip44Params.coinType,
+            bip44Params.accountNumber,
+            ...(bip44Params.isChange !== undefined ? [bip44Params.isChange ? 1 : 0] : []),
+            ...(bip44Params.addressIndex !== undefined ? [bip44Params.addressIndex] : []),
+        ];
+        return {
+            addressNList,
+            intentMessageBytes: intentMessage,
+        };
+    },
+    getSuiTransactionFees: ({ tradeQuote, stepIndex }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        if (!step.feeData.networkFeeCryptoBaseUnit) {
+            throw new Error('Missing network fee in quote');
+        }
+        return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
+    },
+    checkTradeStatus: ({ swap, assertGetSuiChainAdapter }) => {
+        if (!swap?.sellTxHash) {
+            return Promise.resolve({
+                status: TxStatus.Unknown,
+                buyTxHash: undefined,
+                message: undefined,
+            });
+        }
+        return checkSuiSwapStatus({
+            txHash: swap.sellTxHash,
+            address: swap.receiveAddress,
+            assertGetSuiChainAdapter,
+        });
+    },
+};

package/dist/esm/swappers/CetusSwapper/index.d.ts

@@ -0,0 +1 @@
+export * from './utils/constants.js';

package/dist/esm/swappers/CetusSwapper/index.js

@@ -0,0 +1 @@
+export * from './utils/constants.js';

package/dist/esm/swappers/CetusSwapper/swapperApi/getTradeQuote.d.ts

@@ -0,0 +1,3 @@
+import type { Result } from '@sniptt/monads';
+import type { CommonTradeQuoteInput, SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types.js';
+export declare const getTradeQuote: (input: CommonTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;

package/dist/esm/swappers/CetusSwapper/swapperApi/getTradeQuote.js

@@ -0,0 +1,118 @@
+import { suiAssetId } from '@shapeshiftoss/caip';
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { isSupportedChainId } from '../utils/constants.js';
+import { calculateSwapAmounts, findBestPool, getCetusSDK, getCoinType } from '../utils/helpers.js';
+export const getTradeQuote = async (input, deps) => {
+    const { sellAsset, buyAsset, receiveAddress, accountNumber, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, affiliateBps, slippageTolerancePercentageDecimal, } = input;
+    const { assetsById } = deps;
+    if (accountNumber === undefined) {
+        return Err(makeSwapErrorRight({
+            message: `accountNumber is required`,
+            code: TradeQuoteError.InternalError,
+        }));
+    }
+    if (!isSupportedChainId(sellAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!isSupportedChainId(buyAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: buyAsset.chainId },
+        }));
+    }
+    const suiAsset = assetsById[suiAssetId];
+    if (!suiAsset) {
+        return Err(makeSwapErrorRight({
+            message: `suiAsset is required`,
+            code: TradeQuoteError.InternalError,
+        }));
+    }
+    try {
+        const sdk = await getCetusSDK();
+        const sellCoinType = getCoinType(sellAsset);
+        const buyCoinType = getCoinType(buyAsset);
+        const pool = await findBestPool(sdk, sellCoinType, buyCoinType);
+        if (!pool) {
+            return Err(makeSwapErrorRight({
+                message: `No liquidity pool found for ${sellAsset.symbol}/${buyAsset.symbol}`,
+                code: TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const swapResult = await calculateSwapAmounts(sdk, pool, sellAsset, buyAsset, sellAmount);
+        if (!swapResult) {
+            return Err(makeSwapErrorRight({
+                message: `Failed to calculate swap for ${sellAsset.symbol}/${buyAsset.symbol}`,
+                code: TradeQuoteError.QueryFailed,
+            }));
+        }
+        const buyAmountAfterFeesCryptoBaseUnit = swapResult.estimatedAmountOut;
+        const rate = getInputOutputRate({
+            sellAmountCryptoBaseUnit: sellAmount,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const adapter = deps.assertGetSuiChainAdapter(sellAsset.chainId);
+        const dummyAddress = '0x0000000000000000000000000000000000000000000000000000000000000000';
+        const addressForFeeEstimate = receiveAddress ?? dummyAddress;
+        const getFeeDataInput = {
+            to: addressForFeeEstimate,
+            value: sellAmount,
+            chainSpecific: {
+                from: addressForFeeEstimate,
+                tokenId: getCoinType(sellAsset),
+            },
+        };
+        const feeData = await adapter.getFeeData(getFeeDataInput);
+        const protocolFees = {};
+        const quotes = [];
+        const tradeQuote = {
+            id: uuid(),
+            quoteOrRate: 'quote',
+            rate,
+            affiliateBps,
+            receiveAddress,
+            slippageTolerancePercentageDecimal,
+            swapperName: SwapperName.Cetus,
+            steps: [
+                {
+                    accountNumber,
+                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
+                    feeData: {
+                        protocolFees,
+                        networkFeeCryptoBaseUnit: feeData.fast.txFee,
+                        chainSpecific: {
+                            gasBudget: feeData.fast.chainSpecific.gasBudget,
+                            gasPrice: feeData.fast.chainSpecific.gasPrice,
+                        },
+                    },
+                    rate,
+                    source: SwapperName.Cetus,
+                    buyAsset,
+                    sellAsset,
+                    allowanceContract: '0x0',
+                    estimatedExecutionTimeMs: undefined,
+                },
+            ],
+        };
+        quotes.push(tradeQuote);
+        return Ok(quotes);
+    }
+    catch (error) {
+        console.error(error);
+        return Err(makeSwapErrorRight({
+            message: error instanceof Error ? error.message : 'Unknown error getting Cetus quote',
+            code: TradeQuoteError.QueryFailed,
+        }));
+    }
+};

package/dist/esm/swappers/CetusSwapper/swapperApi/getTradeRate.d.ts

@@ -0,0 +1,3 @@
+import type { Result } from '@sniptt/monads';
+import type { GetTradeRateInput, SwapErrorRight, SwapperDeps, TradeRate } from '../../../types.js';
+export declare const getTradeRate: (input: GetTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;

package/dist/esm/swappers/CetusSwapper/swapperApi/getTradeRate.js

@@ -0,0 +1,106 @@
+import { suiAssetId } from '@shapeshiftoss/caip';
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { isSupportedChainId } from '../utils/constants.js';
+import { calculateSwapAmounts, findBestPool, getCetusSDK, getCoinType } from '../utils/helpers.js';
+export const getTradeRate = async (input, deps) => {
+    const { sellAsset, buyAsset, receiveAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, affiliateBps, slippageTolerancePercentageDecimal, } = input;
+    const { assetsById } = deps;
+    if (!isSupportedChainId(sellAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!isSupportedChainId(buyAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: buyAsset.chainId },
+        }));
+    }
+    const suiAsset = assetsById[suiAssetId];
+    if (!suiAsset) {
+        return Err(makeSwapErrorRight({
+            message: `suiAsset is required`,
+            code: TradeQuoteError.UnknownError,
+        }));
+    }
+    try {
+        const sdk = await getCetusSDK();
+        const sellCoinType = getCoinType(sellAsset);
+        const buyCoinType = getCoinType(buyAsset);
+        const pool = await findBestPool(sdk, sellCoinType, buyCoinType);
+        if (!pool) {
+            return Err(makeSwapErrorRight({
+                message: `No liquidity pool found for ${sellAsset.symbol}/${buyAsset.symbol}`,
+                code: TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const swapResult = await calculateSwapAmounts(sdk, pool, sellAsset, buyAsset, sellAmount);
+        if (!swapResult) {
+            return Err(makeSwapErrorRight({
+                message: `Failed to calculate swap for ${sellAsset.symbol}/${buyAsset.symbol}`,
+                code: TradeQuoteError.QueryFailed,
+            }));
+        }
+        const buyAmountAfterFeesCryptoBaseUnit = swapResult.estimatedAmountOut;
+        const rate = getInputOutputRate({
+            sellAmountCryptoBaseUnit: sellAmount,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const adapter = deps.assertGetSuiChainAdapter(sellAsset.chainId);
+        const dummyAddress = '0x0000000000000000000000000000000000000000000000000000000000000000';
+        const addressForFeeEstimate = receiveAddress ?? dummyAddress;
+        const { fast: feeDataFast } = await adapter.getFeeData({
+            to: addressForFeeEstimate,
+            value: sellAmount,
+            chainSpecific: {
+                from: addressForFeeEstimate,
+                tokenId: getCoinType(sellAsset),
+            },
+        });
+        const protocolFees = {};
+        const rates = [];
+        const tradeRate = {
+            id: uuid(),
+            quoteOrRate: 'rate',
+            rate,
+            affiliateBps,
+            receiveAddress,
+            slippageTolerancePercentageDecimal,
+            swapperName: SwapperName.Cetus,
+            steps: [
+                {
+                    accountNumber: undefined,
+                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
+                    feeData: {
+                        protocolFees,
+                        networkFeeCryptoBaseUnit: feeDataFast.txFee,
+                    },
+                    rate,
+                    source: SwapperName.Cetus,
+                    buyAsset,
+                    sellAsset,
+                    allowanceContract: '0x0',
+                    estimatedExecutionTimeMs: undefined,
+                },
+            ],
+        };
+        rates.push(tradeRate);
+        return Ok(rates);
+    }
+    catch (error) {
+        return Err(makeSwapErrorRight({
+            message: error instanceof Error ? error.message : 'Unknown error getting Cetus rate',
+            code: TradeQuoteError.QueryFailed,
+        }));
+    }
+};

package/dist/esm/swappers/CetusSwapper/utils/constants.d.ts

@@ -0,0 +1,3 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+export declare const SUPPORTED_CETUS_CHAIN_IDS: readonly ChainId[];
+export declare const isSupportedChainId: (chainId: ChainId) => chainId is ChainId;

package/dist/esm/swappers/CetusSwapper/utils/constants.js

@@ -0,0 +1,5 @@
+import { suiChainId } from '@shapeshiftoss/caip';
+export const SUPPORTED_CETUS_CHAIN_IDS = [suiChainId];
+export const isSupportedChainId = (chainId) => {
+    return SUPPORTED_CETUS_CHAIN_IDS.includes(chainId);
+};

package/dist/esm/swappers/CetusSwapper/utils/helpers.d.ts

@@ -0,0 +1,13 @@
+import type { CetusClmmSDK, Pool } from '@cetusprotocol/cetus-sui-clmm-sdk';
+import type { Asset } from '@shapeshiftoss/types';
+export declare const getCetusSDK: () => Promise<CetusClmmSDK>;
+export declare const getCoinType: (asset: Asset) => string;
+export declare const determineSwapDirection: (pool: Pool, sellCoinType: string, buyCoinType: string) => boolean;
+export declare const calculateAmountLimit: (estimatedAmount: string, slippageTolerancePercentageDecimal: string | undefined, isBuyAmount: boolean) => string;
+export declare const findBestPool: (sdk: CetusClmmSDK, sellCoinType: string, buyCoinType: string) => Promise<Pool | undefined>;
+export type CalculateSwapResult = {
+    estimatedAmountOut: string;
+    estimatedAmountIn: string;
+    estimatedFeeAmount: string;
+};
+export declare const calculateSwapAmounts: (sdk: CetusClmmSDK, pool: Pool, sellAsset: Asset, buyAsset: Asset, sellAmount: string) => Promise<CalculateSwapResult | undefined>;

package/dist/esm/swappers/CetusSwapper/utils/helpers.js

@@ -0,0 +1,86 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { bn, bnOrZero } from '@shapeshiftoss/utils';
+let sdkInstance;
+export const getCetusSDK = async () => {
+    if (!sdkInstance) {
+        const { initMainnetSDK } = await import('@cetusprotocol/cetus-sui-clmm-sdk');
+        sdkInstance = initMainnetSDK();
+    }
+    return sdkInstance;
+};
+export const getCoinType = (asset) => {
+    const { assetReference, assetNamespace } = fromAssetId(asset.assetId);
+    // For native SUI token, the assetReference is 'slip44:784' but Cetus expects '0x2::sui::SUI'
+    if (assetNamespace === 'slip44') {
+        return '0x2::sui::SUI';
+    }
+    // For other tokens, the assetReference should be the full coin type
+    return assetReference;
+};
+export const determineSwapDirection = (pool, sellCoinType, buyCoinType) => {
+    if (pool.coinTypeA === sellCoinType && pool.coinTypeB === buyCoinType) {
+        return true;
+    }
+    if (pool.coinTypeA === buyCoinType && pool.coinTypeB === sellCoinType) {
+        return false;
+    }
+    throw new Error('Pool does not match the swap pair');
+};
+export const calculateAmountLimit = (estimatedAmount, slippageTolerancePercentageDecimal, isBuyAmount) => {
+    if (!slippageTolerancePercentageDecimal) {
+        return estimatedAmount;
+    }
+    const slippageFactor = bn(1).minus(slippageTolerancePercentageDecimal);
+    if (isBuyAmount) {
+        return bnOrZero(estimatedAmount).times(slippageFactor).toFixed(0);
+    }
+    const maxSlippageFactor = bn(1).plus(slippageTolerancePercentageDecimal);
+    return bnOrZero(estimatedAmount).times(maxSlippageFactor).toFixed(0);
+};
+export const findBestPool = async (sdk, sellCoinType, buyCoinType) => {
+    const pools = await sdk.Pool.getPoolByCoins([sellCoinType, buyCoinType]);
+    if (!pools || pools.length === 0) {
+        return undefined;
+    }
+    const poolWithLiquidity = pools.find(pool => {
+        const hasLiquidity = pool.liquidity && bnOrZero(pool.liquidity).gt(0);
+        return hasLiquidity;
+    });
+    if (!poolWithLiquidity) {
+        console.warn('[Cetus] No pools with liquidity found for', sellCoinType, buyCoinType, {
+            totalPools: pools.length,
+            pools: pools.map(p => ({ id: p.poolAddress, liquidity: p.liquidity })),
+        });
+    }
+    return poolWithLiquidity;
+};
+export const calculateSwapAmounts = async (sdk, pool, sellAsset, buyAsset, sellAmount) => {
+    const sellCoinType = getCoinType(sellAsset);
+    const buyCoinType = getCoinType(buyAsset);
+    const a2b = determineSwapDirection(pool, sellCoinType, buyCoinType);
+    const decimalsA = pool.coinTypeA === sellCoinType ? sellAsset.precision : buyAsset.precision;
+    const decimalsB = pool.coinTypeA === sellCoinType ? buyAsset.precision : sellAsset.precision;
+    const preSwapParams = {
+        pool,
+        currentSqrtPrice: pool.current_sqrt_price,
+        coinTypeA: pool.coinTypeA,
+        coinTypeB: pool.coinTypeB,
+        decimalsA,
+        decimalsB,
+        a2b,
+        byAmountIn: true,
+        amount: sellAmount,
+    };
+    const preSwapResult = await sdk.Swap.preswap(preSwapParams);
+    if (!preSwapResult) {
+        return undefined;
+    }
+    if (preSwapResult.estimatedAmountOut === '0' || preSwapResult.estimatedAmountOut === '') {
+        return undefined;
+    }
+    return {
+        estimatedAmountOut: preSwapResult.estimatedAmountOut,
+        estimatedAmountIn: preSwapResult.estimatedAmountIn,
+        estimatedFeeAmount: preSwapResult.estimatedFeeAmount,
+    };
+};

package/dist/esm/swappers/NearIntentsSwapper/NearIntentsSwapper.js

@@ -1,7 +1,9 @@
-import { executeEvmTransaction, executeSolanaTransaction } from '../../utils.js';
+import { executeEvmTransaction, executeSolanaTransaction, executeSuiTransaction, executeTronTransaction, } from '../../utils.js';
 export const nearIntentsSwapper = {
     executeEvmTransaction,
     executeSolanaTransaction,
+    executeTronTransaction,
+    executeSuiTransaction,
     executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
         return signAndBroadcastTransaction(txToSign);
     },

package/dist/esm/swappers/NearIntentsSwapper/endpoints.js

@@ -1,5 +1,7 @@
 import { evm } from '@shapeshiftoss/chain-adapters';
 import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
+import { getTronTransactionFees } from '../../tron-utils/getTronTransactionFees.js';
+import { getUnsignedTronTransaction } from '../../tron-utils/getUnsignedTronTransaction.js';
 import { createDefaultStatusResponse, getExecutableTradeStep, isExecutableTradeQuote, } from '../../utils.js';
 import { isNativeEvmAsset } from '../utils/helpers/helpers.js';
 import { getTradeQuote } from './swapperApi/getTradeQuote.js';
@@ -136,6 +138,45 @@ export const nearIntentsApi = {
         }
         return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
     },
+    getUnsignedTronTransaction,
+    getTronTransactionFees,
+    getUnsignedSuiTransaction: async ({ stepIndex, tradeQuote, from, assertGetSuiChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { accountNumber, sellAsset, nearIntentsSpecific } = step;
+        if (!nearIntentsSpecific)
+            throw new Error('nearIntentsSpecific is required');
+        const adapter = assertGetSuiChainAdapter(sellAsset.chainId);
+        const to = nearIntentsSpecific.depositAddress;
+        const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
+        const tokenId = contractAddressOrUndefined(sellAsset.assetId);
+        const { fast } = await adapter.getFeeData({
+            to,
+            value,
+            chainSpecific: { from, tokenId },
+        });
+        return adapter.buildSendApiTransaction({
+            to,
+            from,
+            value,
+            accountNumber,
+            chainSpecific: {
+                tokenId,
+                gasBudget: fast.chainSpecific.gasBudget,
+                gasPrice: fast.chainSpecific.gasPrice,
+            },
+        });
+    },
+    getSuiTransactionFees: ({ tradeQuote, stepIndex }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        if (!step.feeData.networkFeeCryptoBaseUnit) {
+            throw new Error('Missing network fee in quote');
+        }
+        return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
+    },
     checkTradeStatus: async ({ config, swap }) => {
         const { nearIntentsSpecific } = swap?.metadata ?? {};
         if (!nearIntentsSpecific?.depositAddress) {
@@ -149,10 +190,12 @@ export const nearIntentsApi = {
             const message = getNearIntentsStatusMessage(statusResponse.status);
             // Extract buyTxHash from destination chain transactions
             const buyTxHash = statusResponse.swapDetails?.destinationChainTxHashes?.[0]?.hash;
+            const actualBuyAmountCryptoBaseUnit = statusResponse.swapDetails?.amountOut;
             return {
                 status: txStatus,
                 buyTxHash,
                 message,
+                actualBuyAmountCryptoBaseUnit,
             };
         }
         catch (error) {