@shapeshiftoss/swapper 17.8.0 → 19.0.0

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

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const caip_1 = require("@shapeshiftoss/caip");
+const vitest_1 = require("vitest");
+const types_1 = require("../../../types");
+const assets_1 = require("../../../utils/test-data/assets");
+const routeQuote_1 = require("../test-data/routeQuote");
+const getButterSwapStepData_1 = require("./getButterSwapStepData");
+// The override path reads live chain state - resolve to no override so estimation exercises the
+// mocked adapter
+vitest_1.vi.mock('../../../utils/evm/stateOverride', async (importOriginal) => ({
+    ...(await importOriginal()),
+    getMinimalStateOverride: vitest_1.vi.fn().mockResolvedValue(undefined),
+}));
+const route = routeQuote_1.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 = { ...assets_1.ETH, assetId: `${caip_1.solanaChainId}/slip44:501`, chainId: caip_1.solanaChainId };
+const TRX = { ...assets_1.ETH, assetId: `${caip_1.tronChainId}/slip44:195`, chainId: caip_1.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 };
+(0, vitest_1.describe)('getButterSwapStepData', () => {
+    (0, vitest_1.describe)('evm', () => {
+        (0, vitest_1.it)('prices the provider gas limit for a rate', async () => {
+            const actual = await (0, getButterSwapStepData_1.getButterSwapStepData)({
+                type: 'rate',
+                input: evmRateInput,
+                deps: makeDeps({ evm: evmAdapter() }),
+                route,
+                sellAsset: assets_1.WETH,
+                feeAsset: assets_1.ETH,
+                sellAmountCryptoBaseUnit: '999000000000000000',
+                spenderAddress: '',
+            });
+            // gasEstimatedTarget 1159118 * gasPrice 1000000000
+            (0, vitest_1.expect)(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '1159118000000000' });
+        });
+        (0, vitest_1.it)('falls back to the provider fee when rate estimation fails', async () => {
+            const actual = await (0, getButterSwapStepData_1.getButterSwapStepData)({
+                type: 'rate',
+                input: evmRateInput,
+                deps: makeDeps({ evm: evmAdapter({ throwOnGasFeeData: true }) }),
+                route,
+                sellAsset: assets_1.WETH,
+                feeAsset: assets_1.ETH,
+                sellAmountCryptoBaseUnit: '999000000000000000',
+                spenderAddress: '',
+            });
+            (0, vitest_1.expect)(actual.unwrap()).toEqual({
+                networkFeeCryptoBaseUnit: PROVIDER_GAS_FEE_BASE_UNIT,
+            });
+        });
+        (0, vitest_1.it)('estimates gas on chain for a quote instead of trusting the provider target', async () => {
+            const actual = await (0, getButterSwapStepData_1.getButterSwapStepData)({
+                type: 'quote',
+                input: evmQuoteInput,
+                from: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                buildTx: evmBuildTx,
+                deps: makeDeps({ evm: evmAdapter({ estimatedGasLimit: '500000' }) }),
+                route,
+                sellAsset: assets_1.WETH,
+                feeAsset: assets_1.ETH,
+                sellAmountCryptoBaseUnit: '999000000000000000',
+                spenderAddress: '',
+            });
+            // gasEstimatedTarget 1159118 is ignored - the tx carries the buffered on chain estimate
+            (0, vitest_1.expect)(actual.unwrap()).toEqual({
+                networkFeeCryptoBaseUnit: '500000000000000',
+                transactionData: {
+                    type: 'evm',
+                    chainId: 1,
+                    to: evmBuildTx.to,
+                    data: evmBuildTx.data,
+                    value: '100000000000000000',
+                    gasLimit: '600000',
+                },
+            });
+        });
+        (0, vitest_1.it)('estimates gas on chain for a quote when the provider omits a target', async () => {
+            const actual = await (0, getButterSwapStepData_1.getButterSwapStepData)({
+                type: 'quote',
+                input: evmQuoteInput,
+                from: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                buildTx: evmBuildTx,
+                deps: makeDeps({ evm: evmAdapter({ estimatedGasLimit: '500000' }) }),
+                route: { ...route, gasEstimatedTarget: '0' },
+                sellAsset: assets_1.WETH,
+                feeAsset: assets_1.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
+            (0, vitest_1.expect)(transactionData).toMatchObject({ gasLimit: '600000' });
+            (0, vitest_1.expect)(networkFeeCryptoBaseUnit).toBe('500000000000000');
+        });
+        (0, vitest_1.it)('errors rather than falling back to the provider fee when quote estimation fails', async () => {
+            const actual = await (0, getButterSwapStepData_1.getButterSwapStepData)({
+                type: 'quote',
+                input: evmQuoteInput,
+                from: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                buildTx: evmBuildTx,
+                deps: makeDeps({ evm: evmAdapter({ throwOnFeeData: true }) }),
+                route: { ...route, gasEstimatedTarget: '0' },
+                sellAsset: assets_1.WETH,
+                feeAsset: assets_1.ETH,
+                sellAmountCryptoBaseUnit: '999000000000000000',
+                spenderAddress: '',
+            });
+            (0, vitest_1.expect)(actual.isErr()).toBe(true);
+            (0, vitest_1.expect)(actual.unwrapErr().code).toBe(types_1.TradeQuoteError.NetworkFeeEstimationFailed);
+        });
+    });
+    (0, vitest_1.describe)('utxo', () => {
+        const utxoAdapter = {
+            getFeeData: () => Promise.resolve({ fast: { txFee: '4200' } }),
+            httpProvider: {
+                getNetworkFees: () => Promise.resolve({ fast: { satsPerKiloByte: 10000 } }),
+            },
+        };
+        (0, vitest_1.it)('estimates off the default vsize for a rate with no pubkey', async () => {
+            const actual = await (0, getButterSwapStepData_1.getButterSwapStepData)({
+                type: 'rate',
+                input: {},
+                deps: makeDeps({ utxo: utxoAdapter }),
+                route,
+                sellAsset: assets_1.BTC,
+                feeAsset: assets_1.BTC,
+                sellAmountCryptoBaseUnit: '100000',
+                spenderAddress: '',
+            });
+            // 10 sats/byte * 200 vbyte default
+            (0, vitest_1.expect)(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '2000' });
+        });
+        (0, vitest_1.it)('builds transaction data with the memo as op return data for a quote', async () => {
+            const actual = await (0, getButterSwapStepData_1.getButterSwapStepData)({
+                type: 'quote',
+                input: { xpub: 'zpub6qux' },
+                from: 'bc1qaddress',
+                buildTx: { ...evmBuildTx, to: 'bc1qbridge', memo: 'butter-memo' },
+                deps: makeDeps({ utxo: utxoAdapter }),
+                route,
+                sellAsset: assets_1.BTC,
+                feeAsset: assets_1.BTC,
+                sellAmountCryptoBaseUnit: '100000',
+                spenderAddress: '',
+            });
+            (0, vitest_1.expect)(actual.unwrap()).toEqual({
+                networkFeeCryptoBaseUnit: '4200',
+                transactionData: {
+                    type: 'utxo',
+                    to: 'bc1qbridge',
+                    opReturnData: 'butter-memo',
+                    value: '100000',
+                },
+            });
+        });
+        (0, vitest_1.it)('errors when the quote is missing the memo the bridge routes on', async () => {
+            const actual = await (0, getButterSwapStepData_1.getButterSwapStepData)({
+                type: 'quote',
+                input: { xpub: 'zpub6qux' },
+                from: 'bc1qaddress',
+                buildTx: { ...evmBuildTx, to: 'bc1qbridge', memo: undefined },
+                deps: makeDeps({ utxo: utxoAdapter }),
+                route,
+                sellAsset: assets_1.BTC,
+                feeAsset: assets_1.BTC,
+                sellAmountCryptoBaseUnit: '100000',
+                spenderAddress: '',
+            });
+            (0, vitest_1.expect)(actual.isErr()).toBe(true);
+            (0, vitest_1.expect)(actual.unwrapErr().code).toBe(types_1.TradeQuoteError.InvalidResponse);
+        });
+    });
+    (0, vitest_1.describe)('solana', () => {
+        (0, vitest_1.it)('uses the provider fee for a rate, since swap instructions do not exist yet', async () => {
+            const assertGetSolanaChainAdapter = vitest_1.vi.fn();
+            const actual = await (0, getButterSwapStepData_1.getButterSwapStepData)({
+                type: 'rate',
+                input: {},
+                deps: { assertGetSolanaChainAdapter },
+                route,
+                sellAsset: SOL,
+                feeAsset: SOL,
+                sellAmountCryptoBaseUnit: '1000000000',
+                spenderAddress: '',
+            });
+            (0, vitest_1.expect)(actual.unwrap()).toEqual({
+                networkFeeCryptoBaseUnit: PROVIDER_GAS_FEE_BASE_UNIT,
+            });
+        });
+    });
+    (0, vitest_1.describe)('tron', () => {
+        (0, vitest_1.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 (0, getButterSwapStepData_1.getButterSwapStepData)({
+                type: 'quote',
+                input: {},
+                from: 'TSenderAddress',
+                buildTx,
+                deps: {},
+                route,
+                sellAsset: TRX,
+                feeAsset: TRX,
+                sellAmountCryptoBaseUnit: '1000000',
+                spenderAddress: '',
+            });
+            (0, vitest_1.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,
+                },
+            });
+        });
+    });
+    (0, vitest_1.it)('errors on an unsupported chain namespace', async () => {
+        const actual = await (0, getButterSwapStepData_1.getButterSwapStepData)({
+            type: 'rate',
+            input: {},
+            deps: {},
+            route,
+            sellAsset: assets_1.RUNE,
+            feeAsset: assets_1.RUNE,
+            sellAmountCryptoBaseUnit: '100000000',
+            spenderAddress: '',
+        });
+        (0, vitest_1.expect)(actual.isErr()).toBe(true);
+        (0, vitest_1.expect)(actual.unwrapErr().code).toBe(types_1.TradeQuoteError.UnsupportedChain);
+    });
+});

package/dist/cjs/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';
+import type { ButterSwapTradeQuoteInput, ButterSwapTradeRateInput, RouteSuccessItem } from '../types';
+import type { GetButterSwapStepDataArgs } from './getButterSwapStepData';
+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/cjs/swappers/ButterSwap/utils/getButterSwapTradeContext.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getButterSwapTradeContext = void 0;
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const affiliateFee_1 = require("../../../utils/affiliateFee");
+const xhr_1 = require("../xhr");
+const constants_1 = require("./constants");
+const helpers_1 = require("./helpers");
+const getButterSwapTradeContext = async ({ input, deps, slippageTolerancePercentageDecimal, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const assertion = (0, helpers_1.assertValidTrade)({ sellAsset });
+    if (assertion.isErr())
+        return (0, monads_1.Err)(assertion.unwrapErr());
+    const slippage = (0, utils_1.convertDecimalPercentageToBasisPoints)(slippageTolerancePercentageDecimal).toString();
+    const routeResult = await (0, xhr_1.getButterRoute)({
+        sellAsset,
+        buyAsset,
+        sellAmountCryptoPrecision: utils_1.BigAmount.fromBaseUnit({
+            value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            precision: sellAsset.precision,
+        }).toPrecision(),
+        slippage,
+        affiliate: (0, constants_1.makeButterSwapAffiliate)(affiliateBps),
+    });
+    if (routeResult.isErr())
+        return (0, monads_1.Err)(routeResult.unwrapErr());
+    const routeResponse = routeResult.unwrap();
+    if (!(0, xhr_1.isRouteSuccess)(routeResponse)) {
+        if (routeResponse.errno === xhr_1.ButterSwapErrorCode.InsufficientAmount) {
+            const minAmountCryptoBaseUnit = utils_1.BigAmount.fromPrecision({
+                value: routeResponse.minAmount,
+                precision: sellAsset.precision,
+            }).toBaseUnit();
+            return (0, monads_1.Err)((0, utils_2.createTradeAmountTooSmallErr)({ minAmountCryptoBaseUnit, assetId: sellAsset.assetId }));
+        }
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `[getButterSwapTradeContext] ${routeResponse.message}`,
+            code: (0, xhr_1.butterSwapErrorToTradeQuoteError)(routeResponse.errno),
+        }));
+    }
+    const route = routeResponse.data[0];
+    if (!route) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: '[getButterSwapTradeContext] No route found',
+            code: types_1.TradeQuoteError.NoRouteFound,
+        }));
+    }
+    const feeAsset = deps.assetsById[(0, utils_1.chainIdToFeeAssetId)(sellAsset.chainId)];
+    if (!feeAsset) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `[getButterSwapTradeContext] Fee asset not found for chainId ${sellAsset.chainId}`,
+            code: types_1.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 = utils_1.BigAmount.fromPrecision({
+        value: outputAmount,
+        precision: buyAsset.precision,
+    }).toBaseUnit();
+    const rate = (0, utils_2.getInputOutputRate)({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    return (0, monads_1.Ok)({
+        tradeCommon: {
+            id: route.hash,
+            rate,
+            swapperName: types_1.SwapperName.ButterSwap,
+            affiliateBps,
+            isStreaming: false,
+            slippageTolerancePercentageDecimal,
+        },
+        stepCommon: {
+            rate,
+            buyAmountBeforeFeesCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            source: types_1.SwapperName.ButterSwap,
+            buyAsset,
+            sellAsset,
+            allowanceContract: route.contract ?? '',
+            estimatedExecutionTimeMs: route.timeEstimated * 1000,
+            affiliateFee: (0, affiliateFee_1.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,
+        },
+    });
+};
+exports.getButterSwapTradeContext = getButterSwapTradeContext;

package/dist/cjs/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';
+import type { RouteSuccessItem } from '../types';
 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/cjs/swappers/ButterSwap/utils/helpers.js

@@ -1,19 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.chainIdToButterSwapChainId = exports.butterSwapChainIdToChainId = void 0;
+exports.getProviderNetworkFeeCryptoBaseUnit = exports.assertValidTrade = exports.chainIdToButterSwapChainId = exports.butterSwapChainIdToChainId = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
 const types_1 = require("@shapeshiftoss/types");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const chains_1 = require("viem/chains");
+const types_2 = require("../../../types");
+const utils_2 = require("../../../utils");
 // 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: types_1.KnownChainIds.EthereumMainnet,
-    137: types_1.KnownChainIds.PolygonMainnet,
-    56: types_1.KnownChainIds.BnbSmartChainMainnet,
-    42161: types_1.KnownChainIds.ArbitrumMainnet,
-    10: types_1.KnownChainIds.OptimismMainnet,
-    8453: types_1.KnownChainIds.BaseMainnet,
-    43114: types_1.KnownChainIds.AvalancheMainnet,
+    [chains_1.mainnet.id]: types_1.KnownChainIds.EthereumMainnet,
+    [chains_1.polygon.id]: types_1.KnownChainIds.PolygonMainnet,
+    [chains_1.bsc.id]: types_1.KnownChainIds.BnbSmartChainMainnet,
+    [chains_1.arbitrum.id]: types_1.KnownChainIds.ArbitrumMainnet,
+    [chains_1.optimism.id]: types_1.KnownChainIds.OptimismMainnet,
+    [chains_1.base.id]: types_1.KnownChainIds.BaseMainnet,
+    [chains_1.avalanche.id]: types_1.KnownChainIds.AvalancheMainnet,
+    [chains_1.robinhood.id]: types_1.KnownChainIds.RobinhoodMainnet,
     1360108768460801: types_1.KnownChainIds.SolanaMainnet,
     1360095883558913: types_1.KnownChainIds.BitcoinMainnet,
-    728126428: types_1.KnownChainIds.TronMainnet,
+    [chains_1.tron.id]: types_1.KnownChainIds.TronMainnet,
 };
 const CHAIN_ID_TO_BUTTERSWAP_CHAIN_ID = Object.entries(BUTTERSWAP_CHAIN_ID_TO_CHAIN_ID).reduce((acc, [butterSwapChainId, chainId]) => {
     acc[chainId] = Number(butterSwapChainId);
@@ -27,3 +35,27 @@ const chainIdToButterSwapChainId = (chainId) => {
     return CHAIN_ID_TO_BUTTERSWAP_CHAIN_ID[chainId];
 };
 exports.chainIdToButterSwapChainId = chainIdToButterSwapChainId;
+const assertValidTrade = ({ sellAsset, }) => {
+    if (!(0, chain_adapters_1.isEvmChainId)(sellAsset.chainId) &&
+        sellAsset.chainId !== caip_1.btcChainId &&
+        sellAsset.chainId !== caip_1.solanaChainId &&
+        sellAsset.chainId !== caip_1.tronChainId) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `Unsupported chain`,
+            code: types_2.TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    return (0, monads_1.Ok)(undefined);
+};
+exports.assertValidTrade = assertValidTrade;
+// 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)
+const getProviderNetworkFeeCryptoBaseUnit = ({ route, feeAsset, }) => {
+    if ((0, utils_1.bnOrZero)(route.gasFee?.amount).lte(0))
+        return '0';
+    return utils_1.BigAmount.fromPrecision({
+        value: route.gasFee.amount,
+        precision: feeAsset.precision,
+    }).toBaseUnit();
+};
+exports.getProviderNetworkFeeCryptoBaseUnit = getProviderNetworkFeeCryptoBaseUnit;

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

@@ -7,7 +7,7 @@ const monads_1 = require("@sniptt/monads");
 const viem_1 = require("viem");
 const types_1 = require("../../types");
 const utils_2 = require("../../utils");
-const helpers_1 = require("../utils/helpers/helpers");
+const helpers_1 = require("../../utils/helpers");
 const butterSwapHistoryService_1 = require("./utils/butterSwapHistoryService");
 const butterSwapService_1 = require("./utils/butterSwapService");
 const helpers_2 = require("./utils/helpers");

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

@@ -14,12 +14,8 @@ const getTradeRate_1 = require("./swapperApi/getTradeRate");
 const constants_2 = require("./utils/constants");
 const helpers_1 = require("./utils/helpers");
 exports.cetusApi = {
-    getTradeQuote: (input, deps) => {
-        return (0, getTradeQuote_1.getTradeQuote)(input, deps);
-    },
-    getTradeRate: (input, deps) => {
-        return (0, getTradeRate_1.getTradeRate)(input, deps);
-    },
+    getTradeQuote: (input, deps) => (0, getTradeQuote_1.getTradeQuote)(input, deps),
+    getTradeRate: (input, deps) => (0, getTradeRate_1.getTradeRate)(input, deps),
     getUnsignedSuiTransaction: async ({ stepIndex, tradeQuote, from, assertGetSuiChainAdapter, config, }) => {
         if (!(0, utils_2.isExecutableTradeQuote)(tradeQuote))
             throw new Error('Unable to execute a trade rate quote');

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

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

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

@@ -14,4 +14,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.cetusSwapper = exports.cetusApi = void 0;
 __exportStar(require("./utils/constants"), exports);
+var endpoints_1 = require("./endpoints");
+Object.defineProperty(exports, "cetusApi", { enumerable: true, get: function () { return endpoints_1.cetusApi; } });
+var CetusSwapper_1 = require("./CetusSwapper");
+Object.defineProperty(exports, "cetusSwapper", { enumerable: true, get: function () { return CetusSwapper_1.cetusSwapper; } });

package/dist/cjs/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';
+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/cjs/swappers/CetusSwapper/swapperApi/getCetusStepData.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCetusStepData = void 0;
+const transactions_1 = require("@mysten/sui/transactions");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const constants_1 = require("../../../constants");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const helpers_1 = require("../utils/helpers");
+async function getCetusStepData(args) {
+    const { routerData, rpcUrl, slippageTolerancePercentageDecimal, from } = args;
+    const client = (0, helpers_1.getAggregatorClient)(rpcUrl);
+    const suiClient = (0, helpers_1.getSuiClient)(rpcUrl);
+    const slippage = (0, utils_1.bnOrZero)(slippageTolerancePercentageDecimal ??
+        (0, constants_1.getDefaultSlippageDecimalPercentageForSwapper)(types_1.SwapperName.Cetus)).toNumber();
+    // Build the actual Cetus swap transaction and dry-run it for an accurate gas estimate
+    const estimateNetworkFeeCryptoBaseUnit = async () => {
+        const txb = new transactions_1.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 (0, monads_1.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 (0, monads_1.Ok)(stepData);
+            }
+            return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getCetusStepData', error));
+        }
+    }
+    try {
+        const networkFeeCryptoBaseUnit = await estimateNetworkFeeCryptoBaseUnit();
+        const stepData = { networkFeeCryptoBaseUnit };
+        return (0, monads_1.Ok)(stepData);
+    }
+    catch (error) {
+        return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getCetusStepData', error));
+    }
+}
+exports.getCetusStepData = getCetusStepData;

package/dist/cjs/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';
+import type { CetusTradeQuoteInput, CetusTradeRateInput } from '../types';
+import type { GetCetusStepDataArgs } from './getCetusStepData';
+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 {};