@shapeshiftoss/swapper 17.8.0 → 18.1.0

package/dist/esm/swappers/ButterSwap/utils/getButterSwapStepData.test.js

@@ -0,0 +1,263 @@
+import { solanaChainId, tronChainId } from '@shapeshiftoss/caip';
+import { describe, expect, it, vi } from 'vitest';
+import { TradeQuoteError } from '../../../types.js';
+import { BTC, ETH, RUNE, WETH } from '../../../utils/test-data/assets.js';
+import { ROUTE_QUOTE } from '../test-data/routeQuote.js';
+import { getButterSwapStepData } from './getButterSwapStepData.js';
+// The override path reads live chain state - resolve to no override so estimation exercises the
+// mocked adapter
+vi.mock('../../../utils/evm/stateOverride', async (importOriginal) => ({
+    ...(await importOriginal()),
+    getMinimalStateOverride: vi.fn().mockResolvedValue(undefined),
+}));
+const route = ROUTE_QUOTE.data[0];
+// The provider gas fee, in human units, that every fallback path prices off of
+const PROVIDER_GAS_FEE_BASE_UNIT = '1333043669759539'; // 0.001333043669759539 ETH
+const SOL = { ...ETH, assetId: `${solanaChainId}/slip44:501`, chainId: solanaChainId };
+const TRX = { ...ETH, assetId: `${tronChainId}/slip44:195`, chainId: tronChainId };
+const evmBuildTx = {
+    to: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+    data: '0xdeadbeef',
+    value: '0x16345785d8a0000',
+    chainId: '1',
+};
+const makeDeps = (adapters) => ({
+    assertGetEvmChainAdapter: () => adapters.evm,
+    assertGetUtxoChainAdapter: () => adapters.utxo,
+    assertGetSolanaChainAdapter: () => adapters.solana,
+});
+const evmAdapter = ({ gasPrice = '1000000000', estimatedGasLimit = '500000', throwOnGasFeeData = false, throwOnFeeData = false, } = {}) => ({
+    getGasFeeData: () => {
+        if (throwOnGasFeeData)
+            return Promise.reject(new Error('rpc down'));
+        return Promise.resolve({ average: { gasPrice, maxFeePerGas: '0', maxPriorityFeePerGas: '0' } });
+    },
+    getFeeData: () => {
+        if (throwOnFeeData)
+            return Promise.reject(new Error('execution reverted'));
+        return Promise.resolve({
+            average: { chainSpecific: { gasLimit: estimatedGasLimit, gasPrice } },
+        });
+    },
+});
+const evmRateInput = { supportsEIP1559: false };
+const evmQuoteInput = { supportsEIP1559: false };
+describe('getButterSwapStepData', () => {
+    describe('evm', () => {
+        it('prices the provider gas limit for a rate', async () => {
+            const actual = await getButterSwapStepData({
+                type: 'rate',
+                input: evmRateInput,
+                deps: makeDeps({ evm: evmAdapter() }),
+                route,
+                sellAsset: WETH,
+                feeAsset: ETH,
+                sellAmountCryptoBaseUnit: '999000000000000000',
+                spenderAddress: '',
+            });
+            // gasEstimatedTarget 1159118 * gasPrice 1000000000
+            expect(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '1159118000000000' });
+        });
+        it('falls back to the provider fee when rate estimation fails', async () => {
+            const actual = await getButterSwapStepData({
+                type: 'rate',
+                input: evmRateInput,
+                deps: makeDeps({ evm: evmAdapter({ throwOnGasFeeData: true }) }),
+                route,
+                sellAsset: WETH,
+                feeAsset: ETH,
+                sellAmountCryptoBaseUnit: '999000000000000000',
+                spenderAddress: '',
+            });
+            expect(actual.unwrap()).toEqual({
+                networkFeeCryptoBaseUnit: PROVIDER_GAS_FEE_BASE_UNIT,
+            });
+        });
+        it('estimates gas on chain for a quote instead of trusting the provider target', async () => {
+            const actual = await getButterSwapStepData({
+                type: 'quote',
+                input: evmQuoteInput,
+                from: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                buildTx: evmBuildTx,
+                deps: makeDeps({ evm: evmAdapter({ estimatedGasLimit: '500000' }) }),
+                route,
+                sellAsset: WETH,
+                feeAsset: ETH,
+                sellAmountCryptoBaseUnit: '999000000000000000',
+                spenderAddress: '',
+            });
+            // gasEstimatedTarget 1159118 is ignored - the tx carries the buffered on chain estimate
+            expect(actual.unwrap()).toEqual({
+                networkFeeCryptoBaseUnit: '500000000000000',
+                transactionData: {
+                    type: 'evm',
+                    chainId: 1,
+                    to: evmBuildTx.to,
+                    data: evmBuildTx.data,
+                    value: '100000000000000000',
+                    gasLimit: '600000',
+                },
+            });
+        });
+        it('estimates gas on chain for a quote when the provider omits a target', async () => {
+            const actual = await getButterSwapStepData({
+                type: 'quote',
+                input: evmQuoteInput,
+                from: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                buildTx: evmBuildTx,
+                deps: makeDeps({ evm: evmAdapter({ estimatedGasLimit: '500000' }) }),
+                route: { ...route, gasEstimatedTarget: '0' },
+                sellAsset: WETH,
+                feeAsset: ETH,
+                sellAmountCryptoBaseUnit: '999000000000000000',
+                spenderAddress: '',
+            });
+            const { transactionData, networkFeeCryptoBaseUnit } = actual.unwrap();
+            // The buffered limit is set on the tx data in place, so the executable tx always carries one
+            expect(transactionData).toMatchObject({ gasLimit: '600000' });
+            expect(networkFeeCryptoBaseUnit).toBe('500000000000000');
+        });
+        it('errors rather than falling back to the provider fee when quote estimation fails', async () => {
+            const actual = await getButterSwapStepData({
+                type: 'quote',
+                input: evmQuoteInput,
+                from: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                buildTx: evmBuildTx,
+                deps: makeDeps({ evm: evmAdapter({ throwOnFeeData: true }) }),
+                route: { ...route, gasEstimatedTarget: '0' },
+                sellAsset: WETH,
+                feeAsset: ETH,
+                sellAmountCryptoBaseUnit: '999000000000000000',
+                spenderAddress: '',
+            });
+            expect(actual.isErr()).toBe(true);
+            expect(actual.unwrapErr().code).toBe(TradeQuoteError.NetworkFeeEstimationFailed);
+        });
+    });
+    describe('utxo', () => {
+        const utxoAdapter = {
+            getFeeData: () => Promise.resolve({ fast: { txFee: '4200' } }),
+            httpProvider: {
+                getNetworkFees: () => Promise.resolve({ fast: { satsPerKiloByte: 10000 } }),
+            },
+        };
+        it('estimates off the default vsize for a rate with no pubkey', async () => {
+            const actual = await getButterSwapStepData({
+                type: 'rate',
+                input: {},
+                deps: makeDeps({ utxo: utxoAdapter }),
+                route,
+                sellAsset: BTC,
+                feeAsset: BTC,
+                sellAmountCryptoBaseUnit: '100000',
+                spenderAddress: '',
+            });
+            // 10 sats/byte * 200 vbyte default
+            expect(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '2000' });
+        });
+        it('builds transaction data with the memo as op return data for a quote', async () => {
+            const actual = await getButterSwapStepData({
+                type: 'quote',
+                input: { xpub: 'zpub6qux' },
+                from: 'bc1qaddress',
+                buildTx: { ...evmBuildTx, to: 'bc1qbridge', memo: 'butter-memo' },
+                deps: makeDeps({ utxo: utxoAdapter }),
+                route,
+                sellAsset: BTC,
+                feeAsset: BTC,
+                sellAmountCryptoBaseUnit: '100000',
+                spenderAddress: '',
+            });
+            expect(actual.unwrap()).toEqual({
+                networkFeeCryptoBaseUnit: '4200',
+                transactionData: {
+                    type: 'utxo',
+                    to: 'bc1qbridge',
+                    opReturnData: 'butter-memo',
+                    value: '100000',
+                },
+            });
+        });
+        it('errors when the quote is missing the memo the bridge routes on', async () => {
+            const actual = await getButterSwapStepData({
+                type: 'quote',
+                input: { xpub: 'zpub6qux' },
+                from: 'bc1qaddress',
+                buildTx: { ...evmBuildTx, to: 'bc1qbridge', memo: undefined },
+                deps: makeDeps({ utxo: utxoAdapter }),
+                route,
+                sellAsset: BTC,
+                feeAsset: BTC,
+                sellAmountCryptoBaseUnit: '100000',
+                spenderAddress: '',
+            });
+            expect(actual.isErr()).toBe(true);
+            expect(actual.unwrapErr().code).toBe(TradeQuoteError.InvalidResponse);
+        });
+    });
+    describe('solana', () => {
+        it('uses the provider fee for a rate, since swap instructions do not exist yet', async () => {
+            const assertGetSolanaChainAdapter = vi.fn();
+            const actual = await getButterSwapStepData({
+                type: 'rate',
+                input: {},
+                deps: { assertGetSolanaChainAdapter },
+                route,
+                sellAsset: SOL,
+                feeAsset: SOL,
+                sellAmountCryptoBaseUnit: '1000000000',
+                spenderAddress: '',
+            });
+            expect(actual.unwrap()).toEqual({
+                networkFeeCryptoBaseUnit: PROVIDER_GAS_FEE_BASE_UNIT,
+            });
+        });
+    });
+    describe('tron', () => {
+        it('returns legacy metadata rather than transaction data, since exec still builds from it', async () => {
+            const buildTx = {
+                ...evmBuildTx,
+                to: 'TRouterAddress',
+                method: 'swapAndCall',
+                args: [{ type: 'address', value: 'TSpender' }],
+            };
+            const actual = await getButterSwapStepData({
+                type: 'quote',
+                input: {},
+                from: 'TSenderAddress',
+                buildTx,
+                deps: {},
+                route,
+                sellAsset: TRX,
+                feeAsset: TRX,
+                sellAmountCryptoBaseUnit: '1000000',
+                spenderAddress: '',
+            });
+            expect(actual.unwrap()).toEqual({
+                networkFeeCryptoBaseUnit: PROVIDER_GAS_FEE_BASE_UNIT,
+                butterSwapTransactionMetadata: {
+                    to: 'TRouterAddress',
+                    data: evmBuildTx.data,
+                    value: evmBuildTx.value,
+                    method: 'swapAndCall',
+                    args: [{ type: 'address', value: 'TSpender' }],
+                    memo: undefined,
+                },
+            });
+        });
+    });
+    it('errors on an unsupported chain namespace', async () => {
+        const actual = await getButterSwapStepData({
+            type: 'rate',
+            input: {},
+            deps: {},
+            route,
+            sellAsset: RUNE,
+            feeAsset: RUNE,
+            sellAmountCryptoBaseUnit: '100000000',
+            spenderAddress: '',
+        });
+        expect(actual.isErr()).toBe(true);
+        expect(actual.unwrapErr().code).toBe(TradeQuoteError.UnsupportedChain);
+    });
+});

package/dist/esm/swappers/ButterSwap/utils/getButterSwapTradeContext.d.ts

@@ -0,0 +1,17 @@
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types.js';
+import type { ButterSwapTradeQuoteInput, ButterSwapTradeRateInput, RouteSuccessItem } from '../types.js';
+import type { GetButterSwapStepDataArgs } from './getButterSwapStepData.js';
+type ButterSwapTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    route: RouteSuccessItem;
+    stepDataArgs: Omit<GetButterSwapStepDataArgs, 'type' | 'input' | 'from' | 'buildTx'>;
+};
+export declare const getButterSwapTradeContext: ({ input, deps, slippageTolerancePercentageDecimal, }: {
+    input: ButterSwapTradeQuoteInput | ButterSwapTradeRateInput;
+    deps: SwapperDeps;
+    slippageTolerancePercentageDecimal: string;
+}) => Promise<Result<ButterSwapTradeContext, SwapErrorRight>>;
+export {};

package/dist/esm/swappers/ButterSwap/utils/getButterSwapTradeContext.js

@@ -0,0 +1,107 @@
+import { BigAmount, chainIdToFeeAssetId, convertDecimalPercentageToBasisPoints, } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { createTradeAmountTooSmallErr, getInputOutputRate, makeSwapErrorRight, } from '../../../utils/index.js';
+import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
+import { ButterSwapErrorCode, butterSwapErrorToTradeQuoteError, getButterRoute, isRouteSuccess, } from '../xhr.js';
+import { makeButterSwapAffiliate } from './constants.js';
+import { assertValidTrade } from './helpers.js';
+export const getButterSwapTradeContext = async ({ input, deps, slippageTolerancePercentageDecimal, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const assertion = assertValidTrade({ sellAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const slippage = convertDecimalPercentageToBasisPoints(slippageTolerancePercentageDecimal).toString();
+    const routeResult = await getButterRoute({
+        sellAsset,
+        buyAsset,
+        sellAmountCryptoPrecision: BigAmount.fromBaseUnit({
+            value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            precision: sellAsset.precision,
+        }).toPrecision(),
+        slippage,
+        affiliate: makeButterSwapAffiliate(affiliateBps),
+    });
+    if (routeResult.isErr())
+        return Err(routeResult.unwrapErr());
+    const routeResponse = routeResult.unwrap();
+    if (!isRouteSuccess(routeResponse)) {
+        if (routeResponse.errno === ButterSwapErrorCode.InsufficientAmount) {
+            const minAmountCryptoBaseUnit = BigAmount.fromPrecision({
+                value: routeResponse.minAmount,
+                precision: sellAsset.precision,
+            }).toBaseUnit();
+            return Err(createTradeAmountTooSmallErr({ minAmountCryptoBaseUnit, assetId: sellAsset.assetId }));
+        }
+        return Err(makeSwapErrorRight({
+            message: `[getButterSwapTradeContext] ${routeResponse.message}`,
+            code: butterSwapErrorToTradeQuoteError(routeResponse.errno),
+        }));
+    }
+    const route = routeResponse.data[0];
+    if (!route) {
+        return Err(makeSwapErrorRight({
+            message: '[getButterSwapTradeContext] No route found',
+            code: TradeQuoteError.NoRouteFound,
+        }));
+    }
+    const feeAsset = deps.assetsById[chainIdToFeeAssetId(sellAsset.chainId)];
+    if (!feeAsset) {
+        return Err(makeSwapErrorRight({
+            message: `[getButterSwapTradeContext] Fee asset not found for chainId ${sellAsset.chainId}`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    // Destination receive amount takes priority; same-chain swaps only carry a source chain amount
+    const outputAmount = route.dstChain?.totalAmountOut ?? route.srcChain.totalAmountOut;
+    const buyAmountAfterFeesCryptoBaseUnit = BigAmount.fromPrecision({
+        value: outputAmount,
+        precision: buyAsset.precision,
+    }).toBaseUnit();
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    return Ok({
+        tradeCommon: {
+            id: route.hash,
+            rate,
+            swapperName: SwapperName.ButterSwap,
+            affiliateBps,
+            isStreaming: false,
+            slippageTolerancePercentageDecimal,
+        },
+        stepCommon: {
+            rate,
+            buyAmountBeforeFeesCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            source: SwapperName.ButterSwap,
+            buyAsset,
+            sellAsset,
+            allowanceContract: route.contract ?? '',
+            estimatedExecutionTimeMs: route.timeEstimated * 1000,
+            affiliateFee: buildAffiliateFee({
+                strategy: 'buy_asset',
+                affiliateBps,
+                sellAsset,
+                buyAsset,
+                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                isEstimate: true,
+            }),
+        },
+        protocolFees: undefined,
+        route,
+        stepDataArgs: {
+            route,
+            feeAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            sellAsset,
+            spenderAddress: route.contract ?? '',
+            deps,
+        },
+    });
+};

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

@@ -1,3 +1,14 @@
 import type { ChainId } from '@shapeshiftoss/caip';
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types.js';
+import type { RouteSuccessItem } from '../types.js';
 export declare const butterSwapChainIdToChainId: (butterSwapChainId: number) => ChainId | undefined;
 export declare const chainIdToButterSwapChainId: (chainId: ChainId) => number | undefined;
+export declare const assertValidTrade: ({ sellAsset, }: {
+    sellAsset: Asset;
+}) => Result<void, SwapErrorRight>;
+export declare const getProviderNetworkFeeCryptoBaseUnit: ({ route, feeAsset, }: {
+    route: RouteSuccessItem;
+    feeAsset: Asset;
+}) => string;

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

@@ -1,4 +1,10 @@
+import { btcChainId, solanaChainId, tronChainId } from '@shapeshiftoss/caip';
+import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
 import { KnownChainIds } from '@shapeshiftoss/types';
+import { BigAmount, bnOrZero } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
 // https://docs.butternetwork.io/butter-swap-integration/butter-api-for-routing/get-supportedchainlist#butter-chain-id-explanation
 const BUTTERSWAP_CHAIN_ID_TO_CHAIN_ID = {
     1: KnownChainIds.EthereumMainnet,
@@ -22,3 +28,25 @@ export const butterSwapChainIdToChainId = (butterSwapChainId) => {
 export const chainIdToButterSwapChainId = (chainId) => {
     return CHAIN_ID_TO_BUTTERSWAP_CHAIN_ID[chainId];
 };
+export const assertValidTrade = ({ sellAsset, }) => {
+    if (!isEvmChainId(sellAsset.chainId) &&
+        sellAsset.chainId !== btcChainId &&
+        sellAsset.chainId !== solanaChainId &&
+        sellAsset.chainId !== tronChainId) {
+        return Err(makeSwapErrorRight({
+            message: `Unsupported chain`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    return Ok(undefined);
+};
+// Provider reported network fee - the rate fallback when estimation fails, and the fee for the
+// un-migrated tron quote path (exec computes the real fee at execution)
+export const getProviderNetworkFeeCryptoBaseUnit = ({ route, feeAsset, }) => {
+    if (bnOrZero(route.gasFee?.amount).lte(0))
+        return '0';
+    return BigAmount.fromPrecision({
+        value: route.gasFee.amount,
+        precision: feeAsset.precision,
+    }).toBaseUnit();
+};

package/dist/esm/swappers/ButterSwap/xhr.js

@@ -3,8 +3,8 @@ import { chainIdToFeeAssetId } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { zeroAddress } from 'viem';
 import { TradeQuoteError } from '../../types.js';
-import { makeSwapErrorRight } from '../../utils.js';
-import { getTreasuryAddressFromChainId } from '../utils/helpers/helpers.js';
+import { makeSwapErrorRight } from '../../utils/index.js';
+import { getTreasuryAddressFromChainId } from '../../utils/helpers.js';
 import { butterHistoryService } from './utils/butterSwapHistoryService.js';
 import { butterService } from './utils/butterSwapService.js';
 import { chainIdToButterSwapChainId } from './utils/helpers.js';

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>>;