@shapeshiftoss/swapper 17.8.0 → 19.0.0

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

@@ -5,18 +5,14 @@ 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 { checkSuiSwapStatus, getExecutableTradeStep, isExecutableTradeQuote } from '../../utils/index.js';
 import { getTradeQuote } from './swapperApi/getTradeQuote.js';
 import { getTradeRate } from './swapperApi/getTradeRate.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);
-    },
-    getTradeRate: (input, deps) => {
-        return getTradeRate(input, deps);
-    },
+    getTradeQuote: (input, deps) => getTradeQuote(input, deps),
+    getTradeRate: (input, deps) => getTradeRate(input, deps),
     getUnsignedSuiTransaction: async ({ stepIndex, tradeQuote, from, assertGetSuiChainAdapter, config, }) => {
         if (!isExecutableTradeQuote(tradeQuote))
             throw new Error('Unable to execute a trade rate quote');

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

@@ -1 +1,3 @@
 export * from './utils/constants.js';
+export { cetusApi } from './endpoints.js';
+export { cetusSwapper } from './CetusSwapper.js';

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

@@ -1 +1,3 @@
 export * from './utils/constants.js';
+export { cetusApi } from './endpoints.js';
+export { cetusSwapper } from './CetusSwapper.js';

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

@@ -0,0 +1,24 @@
+import type { RouterDataV3 } from '@cetusprotocol/aggregator-sdk';
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight } from '../../../types.js';
+type BaseArgs = {
+    routerData: RouterDataV3;
+    rpcUrl: string;
+    slippageTolerancePercentageDecimal: string | undefined;
+};
+export type GetCetusStepDataArgs = StepDataArgs<BaseArgs, {
+    from: string;
+}>;
+type CetusRateStepData = {
+    networkFeeCryptoBaseUnit: string | undefined;
+};
+type CetusQuoteStepData = {
+    networkFeeCryptoBaseUnit: string;
+};
+export declare function getCetusStepData(args: Extract<GetCetusStepDataArgs, {
+    type: 'rate';
+}>): Promise<Result<CetusRateStepData, SwapErrorRight>>;
+export declare function getCetusStepData(args: Extract<GetCetusStepDataArgs, {
+    type: 'quote';
+}>): Promise<Result<CetusQuoteStepData, SwapErrorRight>>;
+export {};

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

@@ -0,0 +1,52 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { bnOrZero } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName } from '../../../types.js';
+import { makeNetworkFeeEstimationFailedErr } from '../../../utils/index.js';
+import { getAggregatorClient, getSuiClient } from '../utils/helpers.js';
+export async function getCetusStepData(args) {
+    const { routerData, rpcUrl, slippageTolerancePercentageDecimal, from } = args;
+    const client = getAggregatorClient(rpcUrl);
+    const suiClient = getSuiClient(rpcUrl);
+    const slippage = bnOrZero(slippageTolerancePercentageDecimal ??
+        getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Cetus)).toNumber();
+    // Build the actual Cetus swap transaction and dry-run it for an accurate gas estimate
+    const estimateNetworkFeeCryptoBaseUnit = async () => {
+        const txb = new Transaction();
+        txb.setSender(from);
+        await client.fastRouterSwap({ router: routerData, slippage, txb, refreshAllCoins: true });
+        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;
+        return (computationCost + netStorageCost).toString();
+    };
+    if (args.type === 'rate') {
+        try {
+            const networkFeeCryptoBaseUnit = await estimateNetworkFeeCryptoBaseUnit();
+            const stepData = { networkFeeCryptoBaseUnit };
+            return Ok(stepData);
+        }
+        catch (error) {
+            // Walletless rates have no coins to dry-run against - degrade to an unknown fee, but a real route/build error still fails
+            if (error instanceof Error && error.message.includes('Not enough coins of type')) {
+                const stepData = { networkFeeCryptoBaseUnit: undefined };
+                return Ok(stepData);
+            }
+            return Err(makeNetworkFeeEstimationFailedErr('getCetusStepData', error));
+        }
+    }
+    try {
+        const networkFeeCryptoBaseUnit = await estimateNetworkFeeCryptoBaseUnit();
+        const stepData = { networkFeeCryptoBaseUnit };
+        return Ok(stepData);
+    }
+    catch (error) {
+        return Err(makeNetworkFeeEstimationFailedErr('getCetusStepData', error));
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types.js';
+import type { CetusTradeQuoteInput, CetusTradeRateInput } from '../types.js';
+import type { GetCetusStepDataArgs } from './getCetusStepData.js';
+type CetusTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    stepDataArgs: Omit<GetCetusStepDataArgs, 'type' | 'input' | 'from'>;
+};
+export declare const getCetusTradeContext: (input: CetusTradeQuoteInput | CetusTradeRateInput, deps: SwapperDeps) => Promise<Result<CetusTradeContext, SwapErrorRight>>;
+export {};

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

@@ -0,0 +1,79 @@
+import { getProvidersExcluding } from '@cetusprotocol/aggregator-sdk';
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils/index.js';
+import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
+import { PYTH_DEPENDENT_PROVIDERS } from '../utils/constants.js';
+import { assertValidTrade, findBestRoute, getAggregatorClient, getCoinType } from '../utils/helpers.js';
+export const getCetusTradeContext = async (input, deps) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const assertion = assertValidTrade({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    try {
+        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,
+        });
+        return Ok({
+            tradeCommon: {
+                id: uuid(),
+                rate,
+                swapperName: SwapperName.Cetus,
+                affiliateBps,
+                slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+            },
+            stepCommon: {
+                rate,
+                buyAmountBeforeFeesCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                buyAmountAfterFeesCryptoBaseUnit,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                source: SwapperName.Cetus,
+                buyAsset,
+                sellAsset,
+                allowanceContract: '',
+                estimatedExecutionTimeMs: undefined,
+                affiliateFee: buildAffiliateFee({
+                    strategy: 'buy_asset',
+                    affiliateBps,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                    isEstimate: true,
+                }),
+            },
+            protocolFees: {},
+            stepDataArgs: {
+                routerData,
+                rpcUrl,
+                slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+                sellAsset,
+                deps,
+            },
+        });
+    }
+    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.d.ts

@@ -1,3 +1,4 @@
 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>>;
+import type { SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types.js';
+import type { CetusTradeQuoteInput } from '../types.js';
+export declare const getTradeQuote: (input: CetusTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;

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

@@ -1,103 +1,39 @@
-import { Transaction } from '@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 { makeSwapErrorRight } from '../../../utils.js';
-import { buildAffiliateFee } from '../../utils/affiliateFee.js';
-import { getAggregatorClient, getSuiClient } from '../utils/helpers.js';
-import { getCetusTradeData } from './getCetusTradeData.js';
+import { Err, Ok } from '@sniptt/monads';
+import { assertQuoteAddresses } from '../../../utils/index.js';
+import { FALLBACK_QUOTE_DEADLINE_MS } from '../../../utils/helpers.js';
+import { getCetusStepData } from './getCetusStepData.js';
+import { getCetusTradeContext } from './getCetusTradeContext.js';
 export const getTradeQuote = async (input, deps) => {
-    const { sellAsset, buyAsset, receiveAddress, accountNumber, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, affiliateBps, slippageTolerancePercentageDecimal, } = input;
-    if (accountNumber === undefined) {
-        return Err(makeSwapErrorRight({
-            message: `accountNumber is required`,
-            code: TradeQuoteError.InternalError,
-        }));
-    }
-    const tradeDataResult = await getCetusTradeData({
-        sellAsset,
-        buyAsset,
+    const { accountNumber, receiveAddress } = input;
+    const maybeAddresses = assertQuoteAddresses(input);
+    if (maybeAddresses.isErr())
+        return Err(maybeAddresses.unwrapErr());
+    const { sendAddress } = maybeAddresses.unwrap();
+    const maybeContext = await getCetusTradeContext(input, deps);
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getCetusStepData({
+        ...stepDataArgs,
+        type: 'quote',
+        input,
+        from: sendAddress,
+    });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeQuote = {
+        ...tradeCommon,
+        quoteOrRate: 'quote',
+        deadline: Date.now() + FALLBACK_QUOTE_DEADLINE_MS,
         receiveAddress,
-        sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
-    }, deps);
-    if (tradeDataResult.isErr())
-        return Err(tradeDataResult.unwrapErr());
-    const { buyAmountAfterFeesCryptoBaseUnit, rate, addressForFeeEstimate, routerData, protocolFees, rpcUrl, } = tradeDataResult.unwrap();
-    try {
-        // 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 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',
-            rate,
-            affiliateBps,
-            receiveAddress,
-            slippageTolerancePercentageDecimal,
-            swapperName: SwapperName.Cetus,
-            steps: [
-                {
-                    accountNumber,
-                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-                    buyAmountAfterFeesCryptoBaseUnit,
-                    sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
-                    feeData: {
-                        protocolFees,
-                        networkFeeCryptoBaseUnit: txFee,
-                        chainSpecific: {
-                            gasBudget,
-                            gasPrice: gasPrice.toString(),
-                        },
-                    },
-                    rate,
-                    source: SwapperName.Cetus,
-                    buyAsset,
-                    sellAsset,
-                    allowanceContract: '0x0',
-                    estimatedExecutionTimeMs: undefined,
-                    affiliateFee: buildAffiliateFee({
-                        strategy: 'buy_asset',
-                        affiliateBps,
-                        sellAsset,
-                        buyAsset,
-                        sellAmountCryptoBaseUnit: sellAmount,
-                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-                        isEstimate: true,
-                    }),
-                },
-            ],
-        };
-        return tradeDataResult.map(() => [tradeQuote]);
-    }
-    catch (error) {
-        console.error(error);
-        return Err(makeSwapErrorRight({
-            message: error instanceof Error ? error.message : 'Unknown error getting Cetus quote',
-            code: TradeQuoteError.QueryFailed,
-        }));
-    }
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
+    };
+    return Ok([tradeQuote]);
 };

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

@@ -1,3 +1,4 @@
 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>>;
+import type { SwapErrorRight, SwapperDeps, TradeRate } from '../../../types.js';
+import type { CetusTradeRateInput } from '../types.js';
+export declare const getTradeRate: (input: CetusTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;

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

@@ -1,100 +1,29 @@
-import { Transaction } from '@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 { makeSwapErrorRight } from '../../../utils.js';
-import { buildAffiliateFee } from '../../utils/affiliateFee.js';
-import { getAggregatorClient, getSuiClient } from '../utils/helpers.js';
-import { getCetusTradeData } from './getCetusTradeData.js';
+import { Err, Ok } from '@sniptt/monads';
+import { CETUS_FEE_ESTIMATE_DUMMY_ADDRESS } from '../utils/constants.js';
+import { getCetusStepData } from './getCetusStepData.js';
+import { getCetusTradeContext } from './getCetusTradeContext.js';
 export const getTradeRate = async (input, deps) => {
-    const { sellAsset, buyAsset, receiveAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, affiliateBps, slippageTolerancePercentageDecimal, } = input;
-    const tradeDataResult = await getCetusTradeData({
-        sellAsset,
-        buyAsset,
+    const { accountNumber, receiveAddress } = input;
+    const from = receiveAddress ?? CETUS_FEE_ESTIMATE_DUMMY_ADDRESS;
+    const maybeContext = await getCetusTradeContext(input, deps);
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getCetusStepData({ ...stepDataArgs, type: 'rate', input, from });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeRate = {
+        ...tradeCommon,
+        quoteOrRate: 'rate',
         receiveAddress,
-        sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
-    }, deps);
-    if (tradeDataResult.isErr())
-        return Err(tradeDataResult.unwrapErr());
-    const { buyAmountAfterFeesCryptoBaseUnit, rate, addressForFeeEstimate, routerData, protocolFees, rpcUrl, } = tradeDataResult.unwrap();
-    try {
-        // 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 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',
-            rate,
-            affiliateBps,
-            receiveAddress,
-            slippageTolerancePercentageDecimal,
-            swapperName: SwapperName.Cetus,
-            steps: [
-                {
-                    accountNumber: undefined,
-                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-                    buyAmountAfterFeesCryptoBaseUnit,
-                    sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
-                    feeData: {
-                        protocolFees,
-                        networkFeeCryptoBaseUnit: txFee,
-                    },
-                    rate,
-                    source: SwapperName.Cetus,
-                    buyAsset,
-                    sellAsset,
-                    allowanceContract: '0x0',
-                    estimatedExecutionTimeMs: undefined,
-                    affiliateFee: buildAffiliateFee({
-                        strategy: 'buy_asset',
-                        affiliateBps,
-                        sellAsset,
-                        buyAsset,
-                        sellAmountCryptoBaseUnit: sellAmount,
-                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-                        isEstimate: true,
-                    }),
-                },
-            ],
-        };
-        return tradeDataResult.map(() => [tradeRate]);
-    }
-    catch (error) {
-        return Err(makeSwapErrorRight({
-            message: error instanceof Error ? error.message : 'Unknown error getting Cetus rate',
-            code: TradeQuoteError.QueryFailed,
-        }));
-    }
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
+    };
+    return Ok([tradeRate]);
 };

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

@@ -0,0 +1,3 @@
+import type { GetSuiTradeQuoteInput, GetSuiTradeRateInput } from '../../types.js';
+export type CetusTradeQuoteInput = GetSuiTradeQuoteInput;
+export type CetusTradeRateInput = GetSuiTradeRateInput;

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

@@ -2,3 +2,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[];
+export declare const CETUS_FEE_ESTIMATE_DUMMY_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000000";

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

@@ -4,3 +4,5 @@ export const isSupportedChainId = (chainId) => {
     return SUPPORTED_CETUS_CHAIN_IDS.includes(chainId);
 };
 export const PYTH_DEPENDENT_PROVIDERS = ['HAEDALPMM', 'HAEDALHMMV2', 'METASTABLE'];
+// Placeholder sender for walletless rate fee estimation - dry-run needs a sender, real coins aren't required
+export const CETUS_FEE_ESTIMATE_DUMMY_ADDRESS = '0x0000000000000000000000000000000000000000000000000000000000000000';

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

@@ -2,7 +2,13 @@ import type { RouterDataV3 } from '@cetusprotocol/aggregator-sdk';
 import { AggregatorClient } from '@cetusprotocol/aggregator-sdk';
 import { SuiClient } from '@mysten/sui/client';
 import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types.js';
 export declare const getAggregatorClient: (rpcUrl: string) => AggregatorClient;
 export declare const getSuiClient: (rpcUrl: string) => SuiClient;
+export declare const assertValidTrade: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Result<void, SwapErrorRight>;
 export declare const getCoinType: (asset: Asset) => string;
 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,6 +1,10 @@
 import { AggregatorClient, Env } from '@cetusprotocol/aggregator-sdk';
 import { SuiClient } from '@mysten/sui/client';
 import { fromAssetId } from '@shapeshiftoss/caip';
+import { Err, Ok } from '@sniptt/monads';
+import { TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
+import { isSupportedChainId } from './constants.js';
 let suiClientInstance;
 let aggregatorClientInstance;
 let currentRpcUrl;
@@ -23,6 +27,23 @@ export const getSuiClient = (rpcUrl) => {
     }
     return suiClientInstance;
 };
+export const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    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 },
+        }));
+    }
+    return Ok(undefined);
+};
 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'

package/dist/esm/swappers/ChainflipSwapper/ChainflipSwapper.js

@@ -1,4 +1,4 @@
-import { executeEvmTransaction, executeSolanaTransaction, executeTronTransaction, } from '../../utils.js';
+import { executeEvmTransaction, executeSolanaTransaction, executeTronTransaction, } from '../../utils/index.js';
 export const chainflipSwapper = {
     executeEvmTransaction,
     executeSolanaTransaction,

package/dist/esm/swappers/ChainflipSwapper/constants.d.ts

@@ -5,6 +5,7 @@ import type { SwapSource } from '../../types.js';
 import { ChainflipNetwork } from './types.js';
 export declare const CHAINFLIP_REGULAR_QUOTE: "regular";
 export declare const CHAINFLIP_DCA_QUOTE: "dca";
+export declare const CHAINFLIP_CHANNEL_DEADLINE_MS: number;
 export declare const ChainflipSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BitcoinMainnet, KnownChainIds.SolanaMainnet, KnownChainIds.TronMainnet];
 export type ChainflipSupportedChainId = (typeof ChainflipSupportedChainIds)[number];
 export declare const ChainflipSupportedAssetIdsByChainId: Partial<Record<KnownChainIds, AssetId[]>>;

package/dist/esm/swappers/ChainflipSwapper/constants.js

@@ -4,6 +4,8 @@ import { SwapperName } from '../../types.js';
 import { ChainflipNetwork } from './types.js';
 export const CHAINFLIP_REGULAR_QUOTE = 'regular';
 export const CHAINFLIP_DCA_QUOTE = 'dca';
+// Deposit channels stay open ~24h - 6h keeps a 4x margin against depositing to an expired channel
+export const CHAINFLIP_CHANNEL_DEADLINE_MS = 6 * 60 * 60 * 1000;
 export const ChainflipSupportedChainIds = [
     KnownChainIds.EthereumMainnet,
     KnownChainIds.ArbitrumMainnet,