@shapeshiftoss/swapper 17.6.7 → 17.6.8

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

@@ -1,8 +1,14 @@
+import { getProvidersExcluding } from '@cetusprotocol/aggregator-sdk';
+import { Transaction } from '@cetusprotocol/aggregator-sdk/node_modules/@mysten/sui/transactions';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
+import { bnOrZero } from '@shapeshiftoss/utils';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../constants.js';
+import { SwapperName } from '../../types.js';
 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';
+import { PYTH_DEPENDENT_PROVIDERS } from './utils/constants.js';
+import { findBestRoute, getAggregatorClient, getCoinType, getSuiClient } from './utils/helpers.js';
 export const cetusApi = {
     getTradeQuote: (input, deps) => {
         return getTradeQuote(input, deps);
@@ -10,36 +16,35 @@ export const cetusApi = {
     getTradeRate: (input, deps) => {
         return getTradeRate(input, deps);
     },
-    getUnsignedSuiTransaction: async ({ stepIndex, tradeQuote, from, assertGetSuiChainAdapter, }) => {
+    getUnsignedSuiTransaction: async ({ stepIndex, tradeQuote, from, assertGetSuiChainAdapter, config, }) => {
         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 rpcUrl = config.VITE_SUI_NODE_URL;
+        const client = getAggregatorClient(rpcUrl);
+        const suiClient = getSuiClient(rpcUrl);
         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}`);
+        // Exclude Pyth-dependent providers to avoid oracle failures
+        const providersWithoutPyth = getProvidersExcluding(PYTH_DEPENDENT_PROVIDERS);
+        const routerData = await findBestRoute(client, sellCoinType, buyCoinType, sellAmountIncludingProtocolFeesCryptoBaseUnit, providersWithoutPyth);
+        if (!routerData) {
+            throw new Error(`No route 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 slippage = bnOrZero(tradeQuote.slippageTolerancePercentageDecimal ??
+            getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Cetus)).toNumber();
+        const txb = new Transaction();
+        txb.setSender(from);
+        await client.fastRouterSwap({
+            router: routerData,
+            slippage,
+            txb,
+            refreshAllCoins: true,
         });
-        const transactionBytes = await tx.build({ client: adapter.getSuiClient() });
+        const transactionJson = await txb.toJSON({ client: suiClient });
+        const transactionBytes = await txb.build({ client: suiClient });
         const intentMessage = new Uint8Array(3 + transactionBytes.length);
         intentMessage[0] = 0;
         intentMessage[1] = 0;
@@ -56,6 +61,7 @@ export const cetusApi = {
         return {
             addressNList,
             intentMessageBytes: intentMessage,
+            transactionJson,
         };
     },
     getSuiTransactionFees: ({ tradeQuote, stepIndex }) => {

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

@@ -0,0 +1,24 @@
+import type { RouterDataV3 } from '@cetusprotocol/aggregator-sdk';
+import type { AssetId } from '@shapeshiftoss/caip';
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { ProtocolFee, SwapErrorRight, SwapperDeps } from '../../../types.js';
+type CetusTradeDataInput = {
+    sellAsset: Asset;
+    buyAsset: Asset;
+    receiveAddress: string | undefined;
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
+};
+type CetusTradeData = {
+    buyAmountAfterFeesCryptoBaseUnit: string;
+    rate: string;
+    addressForFeeEstimate: string;
+    sellCoinType: string;
+    buyCoinType: string;
+    routerData: RouterDataV3;
+    protocolFees: Record<AssetId, ProtocolFee>;
+    adapter: ReturnType<SwapperDeps['assertGetSuiChainAdapter']>;
+    rpcUrl: string;
+};
+export declare const getCetusTradeData: (input: CetusTradeDataInput, deps: SwapperDeps) => Promise<Result<CetusTradeData, SwapErrorRight>>;
+export {};

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

@@ -0,0 +1,75 @@
+import { getProvidersExcluding } from '@cetusprotocol/aggregator-sdk';
+import { suiAssetId } from '@shapeshiftoss/caip';
+import { Err, Ok } from '@sniptt/monads';
+import { TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { isSupportedChainId, PYTH_DEPENDENT_PROVIDERS } from '../utils/constants.js';
+import { findBestRoute, getAggregatorClient, getCoinType } from '../utils/helpers.js';
+export const getCetusTradeData = async (input, deps) => {
+    const { sellAsset, buyAsset, receiveAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit } = 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.InternalError,
+        }));
+    }
+    try {
+        const adapter = deps.assertGetSuiChainAdapter(sellAsset.chainId);
+        const rpcUrl = deps.config.VITE_SUI_NODE_URL;
+        const client = getAggregatorClient(rpcUrl);
+        const sellCoinType = getCoinType(sellAsset);
+        const buyCoinType = getCoinType(buyAsset);
+        // Exclude Pyth-dependent providers to avoid oracle failures
+        const providersWithoutPyth = getProvidersExcluding(PYTH_DEPENDENT_PROVIDERS);
+        const routerData = await findBestRoute(client, sellCoinType, buyCoinType, sellAmountIncludingProtocolFeesCryptoBaseUnit, providersWithoutPyth);
+        if (!routerData) {
+            return Err(makeSwapErrorRight({
+                message: `No route found for ${sellAsset.symbol}/${buyAsset.symbol}`,
+                code: TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const buyAmountAfterFeesCryptoBaseUnit = routerData.amountOut.toString();
+        const rate = getInputOutputRate({
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const dummyAddress = '0x0000000000000000000000000000000000000000000000000000000000000000';
+        const addressForFeeEstimate = receiveAddress ?? dummyAddress;
+        const protocolFees = {};
+        return Ok({
+            buyAmountAfterFeesCryptoBaseUnit,
+            rate,
+            addressForFeeEstimate,
+            sellCoinType,
+            buyCoinType,
+            routerData,
+            protocolFees,
+            adapter,
+            rpcUrl,
+        });
+    }
+    catch (error) {
+        return Err(makeSwapErrorRight({
+            message: error instanceof Error ? error.message : 'Unknown error getting Cetus data',
+            code: TradeQuoteError.QueryFailed,
+        }));
+    }
+};

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

@@ -1,79 +1,55 @@
-import { suiAssetId } from '@shapeshiftoss/caip';
-import { Err, Ok } from '@sniptt/monads';
+import { Transaction } from '@cetusprotocol/aggregator-sdk/node_modules/@mysten/sui/transactions';
+import { bnOrZero } from '@shapeshiftoss/utils';
+import { Err } from '@sniptt/monads';
 import { v4 as uuid } from 'uuid';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
 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';
+import { makeSwapErrorRight } from '../../../utils.js';
+import { getAggregatorClient, getSuiClient } from '../utils/helpers.js';
+import { getCetusTradeData } from './getCetusTradeData.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,
-        }));
-    }
+    const tradeDataResult = await getCetusTradeData({
+        sellAsset,
+        buyAsset,
+        receiveAddress,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
+    }, deps);
+    if (tradeDataResult.isErr())
+        return Err(tradeDataResult.unwrapErr());
+    const { buyAmountAfterFeesCryptoBaseUnit, rate, addressForFeeEstimate, routerData, protocolFees, rpcUrl, } = tradeDataResult.unwrap();
     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,
+        // Build the actual Cetus swap transaction to get accurate gas estimation
+        const client = getAggregatorClient(rpcUrl);
+        const suiClient = getSuiClient(rpcUrl);
+        const slippage = bnOrZero(slippageTolerancePercentageDecimal ??
+            getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Cetus)).toNumber();
+        const txb = new Transaction();
+        txb.setSender(addressForFeeEstimate);
+        await client.fastRouterSwap({
+            router: routerData,
+            slippage,
+            txb,
+            refreshAllCoins: true,
         });
-        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 transactionBytes = await txb.build({ client: suiClient });
+        const dryRunResult = await suiClient.dryRunTransactionBlock({
+            transactionBlock: transactionBytes,
+        });
+        const computationCost = BigInt(dryRunResult.effects.gasUsed.computationCost);
+        const storageCost = BigInt(dryRunResult.effects.gasUsed.storageCost);
+        const storageRebate = BigInt(dryRunResult.effects.gasUsed.storageRebate);
+        const netStorageCost = storageCost > storageRebate ? storageCost - storageRebate : 0n;
+        const estimatedGas = computationCost + netStorageCost;
+        const txFee = estimatedGas.toString();
+        const gasBudget = ((estimatedGas * 120n) / 100n).toString();
+        const gasPrice = await suiClient.getReferenceGasPrice();
         const tradeQuote = {
             id: uuid(),
             quoteOrRate: 'quote',
@@ -90,10 +66,10 @@ export const getTradeQuote = async (input, deps) => {
                     sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
                     feeData: {
                         protocolFees,
-                        networkFeeCryptoBaseUnit: feeData.fast.txFee,
+                        networkFeeCryptoBaseUnit: txFee,
                         chainSpecific: {
-                            gasBudget: feeData.fast.chainSpecific.gasBudget,
-                            gasPrice: feeData.fast.chainSpecific.gasPrice,
+                            gasBudget,
+                            gasPrice: gasPrice.toString(),
                         },
                     },
                     rate,
@@ -105,8 +81,7 @@ export const getTradeQuote = async (input, deps) => {
                 },
             ],
         };
-        quotes.push(tradeQuote);
-        return Ok(quotes);
+        return tradeDataResult.map(() => [tradeQuote]);
     }
     catch (error) {
         console.error(error);

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

@@ -1,72 +1,57 @@
-import { suiAssetId } from '@shapeshiftoss/caip';
-import { Err, Ok } from '@sniptt/monads';
+import { Transaction } from '@cetusprotocol/aggregator-sdk/node_modules/@mysten/sui/transactions';
+import { bnOrZero } from '@shapeshiftoss/utils';
+import { Err } from '@sniptt/monads';
 import { v4 as uuid } from 'uuid';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
 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';
+import { makeSwapErrorRight } from '../../../utils.js';
+import { getAggregatorClient, getSuiClient } from '../utils/helpers.js';
+import { getCetusTradeData } from './getCetusTradeData.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,
-        }));
-    }
+    const tradeDataResult = await getCetusTradeData({
+        sellAsset,
+        buyAsset,
+        receiveAddress,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
+    }, deps);
+    if (tradeDataResult.isErr())
+        return Err(tradeDataResult.unwrapErr());
+    const { buyAmountAfterFeesCryptoBaseUnit, rate, addressForFeeEstimate, routerData, protocolFees, rpcUrl, } = tradeDataResult.unwrap();
     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),
-            },
+        // Build the actual Cetus swap transaction to get accurate gas estimation
+        const client = getAggregatorClient(rpcUrl);
+        const suiClient = getSuiClient(rpcUrl);
+        const slippage = bnOrZero(slippageTolerancePercentageDecimal ??
+            getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Cetus)).toNumber();
+        const txb = new Transaction();
+        txb.setSender(addressForFeeEstimate);
+        await client.fastRouterSwap({
+            router: routerData,
+            slippage,
+            txb,
+            refreshAllCoins: true,
         });
-        const protocolFees = {};
-        const rates = [];
+        const txFee = await (async () => {
+            try {
+                const transactionBytes = await txb.build({ client: suiClient });
+                const dryRunResult = await suiClient.dryRunTransactionBlock({
+                    transactionBlock: transactionBytes,
+                });
+                const computationCost = BigInt(dryRunResult.effects.gasUsed.computationCost);
+                const storageCost = BigInt(dryRunResult.effects.gasUsed.storageCost);
+                const storageRebate = BigInt(dryRunResult.effects.gasUsed.storageRebate);
+                const netStorageCost = storageCost > storageRebate ? storageCost - storageRebate : 0n;
+                const estimatedGas = computationCost + netStorageCost;
+                return estimatedGas.toString();
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes('Not enough coins of type')) {
+                    return undefined;
+                }
+                throw error;
+            }
+        })();
         const tradeRate = {
             id: uuid(),
             quoteOrRate: 'rate',
@@ -83,7 +68,7 @@ export const getTradeRate = async (input, deps) => {
                     sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
                     feeData: {
                         protocolFees,
-                        networkFeeCryptoBaseUnit: feeDataFast.txFee,
+                        networkFeeCryptoBaseUnit: txFee,
                     },
                     rate,
                     source: SwapperName.Cetus,
@@ -94,8 +79,7 @@ export const getTradeRate = async (input, deps) => {
                 },
             ],
         };
-        rates.push(tradeRate);
-        return Ok(rates);
+        return tradeDataResult.map(() => [tradeRate]);
     }
     catch (error) {
         return Err(makeSwapErrorRight({

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

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

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

@@ -3,3 +3,4 @@ export const SUPPORTED_CETUS_CHAIN_IDS = [suiChainId];
 export const isSupportedChainId = (chainId) => {
     return SUPPORTED_CETUS_CHAIN_IDS.includes(chainId);
 };
+export const PYTH_DEPENDENT_PROVIDERS = ['HAEDALPMM', 'HAEDALHMMV2', 'METASTABLE'];

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

@@ -1,13 +1,8 @@
-import type { CetusClmmSDK, Pool } from '@cetusprotocol/cetus-sui-clmm-sdk';
+import type { RouterDataV3 } from '@cetusprotocol/aggregator-sdk';
+import { AggregatorClient } from '@cetusprotocol/aggregator-sdk';
+import { SuiClient } from '@cetusprotocol/aggregator-sdk/node_modules/@mysten/sui/client';
 import type { Asset } from '@shapeshiftoss/types';
-export declare const getCetusSDK: () => Promise<CetusClmmSDK>;
+export declare const getAggregatorClient: (rpcUrl: string) => AggregatorClient;
+export declare const getSuiClient: (rpcUrl: string) => SuiClient;
 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>;
+export declare const findBestRoute: (client: AggregatorClient, sellCoinType: string, buyCoinType: string, sellAmountCryptoBaseUnit: string, providers?: string[]) => Promise<RouterDataV3 | undefined>;

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

@@ -1,12 +1,27 @@
+import { AggregatorClient, Env } from '@cetusprotocol/aggregator-sdk';
+import { SuiClient } from '@cetusprotocol/aggregator-sdk/node_modules/@mysten/sui/client';
 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();
+let suiClientInstance;
+let aggregatorClientInstance;
+let currentRpcUrl;
+export const getAggregatorClient = (rpcUrl) => {
+    if (!aggregatorClientInstance || !suiClientInstance || currentRpcUrl !== rpcUrl) {
+        suiClientInstance = new SuiClient({ url: rpcUrl });
+        aggregatorClientInstance = new AggregatorClient({
+            client: suiClientInstance,
+            env: Env.Mainnet,
+            signer: '0x0',
+        });
+        currentRpcUrl = rpcUrl;
+    }
+    return aggregatorClientInstance;
+};
+export const getSuiClient = (rpcUrl) => {
+    if (!suiClientInstance || currentRpcUrl !== rpcUrl) {
+        suiClientInstance = new SuiClient({ url: rpcUrl });
+        currentRpcUrl = rpcUrl;
     }
-    return sdkInstance;
+    return suiClientInstance;
 };
 export const getCoinType = (asset) => {
     const { assetReference, assetNamespace } = fromAssetId(asset.assetId);
@@ -17,70 +32,25 @@ export const getCoinType = (asset) => {
     // 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;
+export const findBestRoute = async (client, sellCoinType, buyCoinType, sellAmountCryptoBaseUnit, providers) => {
+    const routerData = await client.findRouters({
+        from: sellCoinType,
+        target: buyCoinType,
+        amount: sellAmountCryptoBaseUnit,
+        byAmountIn: true,
+        ...(providers && { providers }),
     });
-    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 })),
-        });
+    if (!routerData) {
+        console.warn('[Cetus Aggregator] No route found for', sellCoinType, buyCoinType);
+        return undefined;
     }
-    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) {
+    if (routerData.insufficientLiquidity) {
+        console.warn('[Cetus Aggregator] Insufficient liquidity for', sellCoinType, buyCoinType);
         return undefined;
     }
-    if (preSwapResult.estimatedAmountOut === '0' || preSwapResult.estimatedAmountOut === '') {
+    if (routerData.error) {
+        console.warn('[Cetus Aggregator] Error finding route:', routerData.error);
         return undefined;
     }
-    return {
-        estimatedAmountOut: preSwapResult.estimatedAmountOut,
-        estimatedAmountIn: preSwapResult.estimatedAmountIn,
-        estimatedFeeAmount: preSwapResult.estimatedFeeAmount,
-    };
+    return routerData;
 };

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

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import type { QuoteResponse, SwapInstructionsResponse } from '@jup-ag/api';
 import type { ChainId } from '@shapeshiftoss/caip';
 import type { solana } from '@shapeshiftoss/chain-adapters';

package/dist/esm/swappers/MayachainSwapper/generated/generatedTradableAssetMap.json

@@ -21,5 +21,6 @@
     "ETH.USDT-0XDAC17F958D2EE523A2206206994597C13D831EC7": "eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7",
     "ETH.WSTETH-0X7F39C581F595B53C5CB19BD0B3F8DA6C935E2CA0": "eip155:1/erc20:0x7f39c581f595b53c5cb19bd0b3f8da6c935e2ca0",
     "THOR.RUNE": "cosmos:thorchain-1/slip44:931",
+    "ZEC.ZEC": "bip122:00040fe8ec8471911baa1db1266ea15d/slip44:133",
     "MAYA.CACAO": "cosmos:mayachain-mainnet-v1/slip44:931"
 }