@shapeshiftoss/swapper 17.7.3 → 18.1.0

package/dist/esm/swappers/ArbitrumBridgeSwapper/utils/fetchArbitrumBridgeSwap.js

@@ -1,143 +0,0 @@
-import { Erc20Bridger, EthBridger, getArbitrumNetwork } from '@arbitrum/sdk';
-import { ethAssetId, ethChainId, fromAssetId } from '@shapeshiftoss/caip';
-import { getEthersV5Provider } from '@shapeshiftoss/contracts';
-import { KnownChainIds } from '@shapeshiftoss/types';
-import { assertUnreachable } from '@shapeshiftoss/utils';
-import { BigNumber } from 'ethers5';
-import { arbitrum } from 'viem/chains';
-import { BRIDGE_TYPE } from '../types.js';
-import { getNetworkFeeOrFallbackCryptoBaseUnit } from './helpers.js';
-const fetchArbitrumBridgeSwap = async ({ chainId, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset, sendAddress, receiveAddress, supportsEIP1559, assertGetEvmChainAdapter, quoteOrRate, }) => {
-    if (quoteOrRate === 'quote' && !receiveAddress)
-        throw new Error('receiveAddress is required for Arbitrum Bridge quotes');
-    if (quoteOrRate === 'quote' && !sendAddress)
-        throw new Error('sendAddress is required for Arbitrum Bridge quotes');
-    const adapter = assertGetEvmChainAdapter(chainId);
-    const l2Network = await getArbitrumNetwork(arbitrum.id);
-    const isDeposit = sellAsset.chainId === ethChainId;
-    const isEthBridge = isDeposit ? sellAsset.assetId === ethAssetId : buyAsset.assetId === ethAssetId;
-    const bridgeType = (() => {
-        if (isDeposit) {
-            return isEthBridge ? BRIDGE_TYPE.ETH_DEPOSIT : BRIDGE_TYPE.ERC20_DEPOSIT;
-        }
-        return isEthBridge ? BRIDGE_TYPE.ETH_WITHDRAWAL : BRIDGE_TYPE.ERC20_WITHDRAWAL;
-    })();
-    const parentProvider = getEthersV5Provider(KnownChainIds.EthereumMainnet);
-    const childProvider = getEthersV5Provider(KnownChainIds.ArbitrumMainnet);
-    switch (bridgeType) {
-        case BRIDGE_TYPE.ETH_DEPOSIT: {
-            const bridger = new EthBridger(l2Network);
-            const maybeRequest = quoteOrRate === 'quote'
-                ? await bridger
-                    .getDepositToRequest({
-                    parentProvider,
-                    childProvider,
-                    amount: BigNumber.from(sellAmountIncludingProtocolFeesCryptoBaseUnit),
-                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !sendAddress)` above
-                    from: sendAddress ?? '',
-                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !receiveAddress)` above
-                    destinationAddress: receiveAddress ?? '',
-                })
-                    .catch(e => {
-                    console.error('Error getting ETH deposit request', e);
-                    return undefined;
-                })
-                : undefined;
-            const networkFeeCryptoBaseUnit = await getNetworkFeeOrFallbackCryptoBaseUnit({
-                maybeRequest,
-                bridgeType,
-                supportsEIP1559,
-                adapter,
-            });
-            return { request: maybeRequest, networkFeeCryptoBaseUnit, allowanceContract: '0x0' };
-        }
-        case BRIDGE_TYPE.ETH_WITHDRAWAL: {
-            const bridger = new EthBridger(l2Network);
-            const maybeRequest = quoteOrRate === 'quote'
-                ? await bridger
-                    .getWithdrawalRequest({
-                    amount: BigNumber.from(sellAmountIncludingProtocolFeesCryptoBaseUnit),
-                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !sendAddress)` above
-                    from: sendAddress ?? '',
-                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !receiveAddress)` above
-                    destinationAddress: receiveAddress ?? '',
-                })
-                    .catch(e => {
-                    console.error('Error getting ETH withdraw request', e);
-                    return undefined;
-                })
-                : undefined;
-            const networkFeeCryptoBaseUnit = await getNetworkFeeOrFallbackCryptoBaseUnit({
-                maybeRequest,
-                bridgeType,
-                supportsEIP1559,
-                adapter,
-            });
-            return { request: maybeRequest, networkFeeCryptoBaseUnit, allowanceContract: '0x0' };
-        }
-        case BRIDGE_TYPE.ERC20_DEPOSIT: {
-            const bridger = new Erc20Bridger(l2Network);
-            const erc20ParentAddress = fromAssetId(sellAsset.assetId).assetReference;
-            const allowanceContract = await bridger.getParentGatewayAddress(erc20ParentAddress, parentProvider);
-            const maybeRequest = quoteOrRate === 'quote'
-                ? await bridger
-                    .getDepositRequest({
-                    amount: BigNumber.from(sellAmountIncludingProtocolFeesCryptoBaseUnit),
-                    parentProvider,
-                    childProvider,
-                    erc20ParentAddress,
-                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !sendAddress)` above
-                    from: sendAddress ?? '',
-                    destinationAddress: receiveAddress,
-                    retryableGasOverrides: {
-                        // https://github.com/OffchainLabs/arbitrum-token-bridge/blob/d17c88ef3eef3f4ffc61a04d34d50406039f045d/packages/arb-token-bridge-ui/src/util/TokenDepositUtils.ts#L159
-                        // the gas limit may vary by about 20k due to SSTORE (zero vs nonzero)
-                        // the 30% gas limit increase should cover the difference
-                        gasLimit: { percentIncrease: BigNumber.from(30) },
-                    },
-                })
-                    .catch(e => {
-                    console.error('Error getting ERC20 deposit request', e);
-                    return undefined;
-                })
-                : undefined;
-            const networkFeeCryptoBaseUnit = await getNetworkFeeOrFallbackCryptoBaseUnit({
-                maybeRequest,
-                bridgeType,
-                supportsEIP1559,
-                adapter,
-            });
-            return { request: maybeRequest, networkFeeCryptoBaseUnit, allowanceContract };
-        }
-        case BRIDGE_TYPE.ERC20_WITHDRAWAL: {
-            const bridger = new Erc20Bridger(l2Network);
-            const erc20ParentAddress = fromAssetId(buyAsset.assetId).assetReference;
-            const maybeRequest = quoteOrRate === 'quote'
-                ? await bridger
-                    .getWithdrawalRequest({
-                    amount: BigNumber.from(sellAmountIncludingProtocolFeesCryptoBaseUnit),
-                    erc20ParentAddress,
-                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !sendAddress)` above
-                    from: sendAddress ?? '',
-                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !receiveAddress)` above
-                    destinationAddress: receiveAddress ?? '',
-                })
-                    .catch(e => {
-                    console.error('Error getting ERC20 withdraw request', e);
-                    return undefined;
-                })
-                : undefined;
-            const networkFeeCryptoBaseUnit = await getNetworkFeeOrFallbackCryptoBaseUnit({
-                maybeRequest,
-                bridgeType,
-                supportsEIP1559,
-                adapter,
-            });
-            return { request: maybeRequest, networkFeeCryptoBaseUnit, allowanceContract: '0x0' };
-        }
-        default:
-            return assertUnreachable(bridgeType);
-    }
-};
-export const fetchArbitrumBridgePrice = (args) => fetchArbitrumBridgeSwap({ ...args, quoteOrRate: 'rate' });
-export const fetchArbitrumBridgeQuote = (args) => fetchArbitrumBridgeSwap({ ...args, quoteOrRate: 'quote' });

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

@@ -1,24 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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/ChainflipSwapper/utils/getEvmTxFees.d.ts

@@ -1,8 +0,0 @@
-import type { EvmChainAdapter } from '@shapeshiftoss/chain-adapters';
-type GetEvmTxFeesArgs = {
-    adapter: EvmChainAdapter;
-    supportsEIP1559: boolean;
-    sendAsset: string;
-};
-export declare const getEvmTxFees: (args: GetEvmTxFeesArgs) => Promise<string>;
-export {};

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

@@ -1,11 +0,0 @@
-import { evm } from '@shapeshiftoss/chain-adapters';
-const SAFE_GAS_LIMIT = '100000';
-export const getEvmTxFees = async (args) => {
-    const { adapter, supportsEIP1559 } = args;
-    const { average } = await adapter.getGasFeeData();
-    return evm.calcNetworkFeeCryptoBaseUnit({
-        ...average,
-        supportsEIP1559,
-        gasLimit: SAFE_GAS_LIMIT,
-    });
-};

package/dist/esm/swappers/ChainflipSwapper/utils/getQuoteOrRate.d.ts

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

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

@@ -1,316 +0,0 @@
-import { CHAIN_NAMESPACE, fromAssetId, solAssetId } from '@shapeshiftoss/caip';
-import { assertUnreachable, BigAmount, bnOrZero } from '@shapeshiftoss/utils';
-import { Err, Ok } from '@sniptt/monads';
-import { v4 as uuid } from 'uuid';
-import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
-import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { createTradeAmountTooSmallErr, getInputOutputRate, makeSwapErrorRight, } from '../../../utils.js';
-import { buildAffiliateFee } from '../../utils/affiliateFee.js';
-import { CHAINFLIP_BOOST_SWAP_SOURCE, CHAINFLIP_DCA_BOOST_SWAP_SOURCE, CHAINFLIP_DCA_QUOTE, CHAINFLIP_DCA_SWAP_SOURCE, CHAINFLIP_REGULAR_QUOTE, CHAINFLIP_SWAP_SOURCE, usdcAsset, } from '../constants.js';
-import { chainflipService } from './chainflipService.js';
-import { getEvmTxFees } from './getEvmTxFees.js';
-import { getUtxoTxFees } from './getUtxoTxFees.js';
-import { getChainFlipIdFromAssetId, isSupportedAssetId, isSupportedChainId } from './helpers.js';
-export const getQuoteOrRate = async (input, deps) => {
-    const { accountNumber, receiveAddress, sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps: commissionBps, quoteOrRate, } = input;
-    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: sellAsset.chainId },
-        }));
-    }
-    if (!isSupportedAssetId(sellAsset.chainId, sellAsset.assetId)) {
-        return Err(makeSwapErrorRight({
-            message: `asset '${sellAsset.name}' on chainId '${sellAsset.chainId}' not supported`,
-            code: TradeQuoteError.UnsupportedTradePair,
-            details: { chainId: sellAsset.chainId, assetId: sellAsset.assetId },
-        }));
-    }
-    if (!isSupportedAssetId(buyAsset.chainId, buyAsset.assetId)) {
-        return Err(makeSwapErrorRight({
-            message: `asset '${buyAsset.name}' on chainId '${buyAsset.chainId}' not supported`,
-            code: TradeQuoteError.UnsupportedTradePair,
-            details: { chainId: buyAsset.chainId, assetId: buyAsset.assetId },
-        }));
-    }
-    const brokerUrl = deps.config.VITE_CHAINFLIP_API_URL;
-    const apiKey = deps.config.VITE_CHAINFLIP_API_KEY;
-    const maybeSourceAsset = await getChainFlipIdFromAssetId({
-        assetId: sellAsset.assetId,
-        brokerUrl,
-    });
-    const maybeDestinationAsset = await getChainFlipIdFromAssetId({
-        assetId: buyAsset.assetId,
-        brokerUrl,
-    });
-    if (maybeSourceAsset.isErr())
-        return Err(maybeSourceAsset.unwrapErr());
-    if (maybeDestinationAsset.isErr())
-        return Err(maybeDestinationAsset.unwrapErr());
-    const sourceAsset = maybeSourceAsset.unwrap();
-    const destinationAsset = maybeDestinationAsset.unwrap();
-    const serviceCommission = parseInt(commissionBps);
-    const maybeQuoteResponse = await chainflipService.get(`${brokerUrl}/quotes-native` +
-        `?apiKey=${apiKey}` +
-        `&sourceAsset=${sourceAsset}` +
-        `&destinationAsset=${destinationAsset}` +
-        `&amount=${sellAmountIncludingProtocolFeesCryptoBaseUnit}` +
-        `&commissionBps=${serviceCommission}`);
-    if (maybeQuoteResponse.isErr()) {
-        const error = maybeQuoteResponse.unwrapErr();
-        const cause = error.cause;
-        if (cause?.message?.includes('code 400') &&
-            cause?.response?.data?.detail?.includes('Amount outside asset bounds')) {
-            return Err(createTradeAmountTooSmallErr({
-                assetId: sellAsset.assetId,
-                minAmountCryptoBaseUnit: cause.response?.data?.errors?.minimalAmountNative?.[0],
-            }));
-        }
-        return Err(makeSwapErrorRight({
-            message: 'Quote request failed',
-            code: TradeQuoteError.NoRouteFound,
-        }));
-    }
-    const { data: quoteResponse } = maybeQuoteResponse.unwrap();
-    const getFeeData = async () => {
-        const { chainNamespace } = fromAssetId(sellAsset.assetId);
-        switch (chainNamespace) {
-            case CHAIN_NAMESPACE.Evm: {
-                const sellAdapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
-                const networkFeeCryptoBaseUnit = await getEvmTxFees({
-                    adapter: sellAdapter,
-                    supportsEIP1559: input.supportsEIP1559,
-                    sendAsset: sourceAsset,
-                });
-                return { networkFeeCryptoBaseUnit };
-            }
-            case CHAIN_NAMESPACE.Utxo: {
-                const sellAdapter = deps.assertGetUtxoChainAdapter(sellAsset.chainId);
-                const pubKey = input.xpub;
-                return await getUtxoTxFees({
-                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                    sellAdapter,
-                    pubKey,
-                });
-            }
-            case CHAIN_NAMESPACE.Solana: {
-                if (!input.sendAddress)
-                    return { networkFeeCryptoBaseUnit: undefined };
-                const sellAdapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
-                const getFeeDataInput = {
-                    // Simulates a self-send, since we don't know the 'to' just yet at this stage
-                    to: input.sendAddress,
-                    value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                    chainSpecific: {
-                        from: input.sendAddress,
-                        tokenId: sellAsset.assetId === solAssetId
-                            ? undefined
-                            : fromAssetId(sellAsset.assetId).assetReference,
-                    },
-                };
-                const { fast } = await sellAdapter.getFeeData(getFeeDataInput);
-                return { networkFeeCryptoBaseUnit: fast.txFee };
-            }
-            default:
-                throw new Error('Unsupported chainNamespace');
-        }
-    };
-    const getFeeAsset = (fee) => {
-        if (fee.type === 'ingress' || fee.type === 'boost')
-            return sellAsset;
-        if (fee.type === 'egress')
-            return buyAsset;
-        if (fee.type === 'liquidity' && fee.asset === sourceAsset)
-            return sellAsset;
-        if (fee.type === 'liquidity' && fee.asset === destinationAsset)
-            return buyAsset;
-        if (fee.type === 'liquidity' && fee.asset === 'usdc.eth')
-            return usdcAsset;
-        if (fee.type === 'network')
-            return usdcAsset;
-    };
-    const getProtocolFees = (singleQuoteResponse) => {
-        const protocolFees = {};
-        for (const fee of singleQuoteResponse.includedFees ?? []) {
-            if (fee.type === 'broker')
-                continue;
-            const asset = getFeeAsset(fee);
-            if (!asset)
-                continue;
-            if (!(asset.assetId in protocolFees)) {
-                protocolFees[asset.assetId] = {
-                    amountCryptoBaseUnit: '0',
-                    requiresBalance: false,
-                    asset,
-                };
-            }
-            protocolFees[asset.assetId].amountCryptoBaseUnit = (BigInt(protocolFees[asset.assetId].amountCryptoBaseUnit) + BigInt(fee.amountNative ?? '0')).toString();
-        }
-        return protocolFees;
-    };
-    const getChainflipQuoteRate = (sellAmountCryptoBaseUnit, buyAmountCryptoBaseUnit) => {
-        return getInputOutputRate({
-            sellAmountCryptoBaseUnit,
-            buyAmountCryptoBaseUnit,
-            sellAsset,
-            buyAsset,
-        });
-    };
-    const getSwapSource = (swapType, isBoosted) => {
-        if (swapType === CHAINFLIP_REGULAR_QUOTE) {
-            return isBoosted ? CHAINFLIP_BOOST_SWAP_SOURCE : CHAINFLIP_SWAP_SOURCE;
-        }
-        if (swapType === CHAINFLIP_DCA_QUOTE) {
-            return isBoosted ? CHAINFLIP_DCA_BOOST_SWAP_SOURCE : CHAINFLIP_DCA_SWAP_SOURCE;
-        }
-        return assertUnreachable(swapType);
-    };
-    const getMaxBoostFee = () => {
-        const { chainNamespace } = fromAssetId(sellAsset.assetId);
-        switch (chainNamespace) {
-            case CHAIN_NAMESPACE.Evm:
-                return 0;
-            case CHAIN_NAMESPACE.Utxo:
-                return 10;
-            case CHAIN_NAMESPACE.Solana:
-                return 0;
-            default:
-                throw new Error('Unsupported chainNamespace');
-        }
-    };
-    const ratesOrQuotes = [];
-    for (const singleQuoteResponse of quoteResponse) {
-        const isStreaming = singleQuoteResponse.type === CHAINFLIP_DCA_QUOTE;
-        if (isStreaming && !deps.config.VITE_FEATURE_CHAINFLIP_SWAP_DCA)
-            continue;
-        const feeData = await getFeeData();
-        if (!singleQuoteResponse.type)
-            throw new Error('Missing quote type');
-        if (singleQuoteResponse.boostQuote &&
-            singleQuoteResponse.boostQuote.ingressAmountNative &&
-            singleQuoteResponse.boostQuote.egressAmountNative) {
-            const boostRate = getChainflipQuoteRate(singleQuoteResponse.boostQuote.ingressAmountNative, singleQuoteResponse.boostQuote.egressAmountNative);
-            // This is not really a buyAmount before fees but rather an input/output calculation to get the sell amount
-            // prorated to the buy asset price to determine price impact
-            const buyAmountBeforeFeesCryptoBaseUnit = BigAmount.fromPrecision({
-                value: bnOrZero(singleQuoteResponse.boostQuote.ingressAmount).times(bnOrZero(singleQuoteResponse.estimatedPrice)),
-                precision: buyAsset.precision,
-            }).toBaseUnit();
-            const boostTradeRateOrQuote = {
-                id: uuid(),
-                rate: boostRate,
-                receiveAddress,
-                quoteOrRate,
-                affiliateBps: commissionBps,
-                isStreaming,
-                slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal ??
-                    getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Chainflip),
-                swapperName: SwapperName.Chainflip,
-                steps: [
-                    {
-                        buyAmountBeforeFeesCryptoBaseUnit,
-                        buyAmountAfterFeesCryptoBaseUnit: singleQuoteResponse.boostQuote.egressAmountNative,
-                        sellAmountIncludingProtocolFeesCryptoBaseUnit: singleQuoteResponse.boostQuote.ingressAmountNative,
-                        feeData: {
-                            protocolFees: getProtocolFees(singleQuoteResponse.boostQuote),
-                            ...feeData,
-                        },
-                        rate: boostRate,
-                        source: getSwapSource(singleQuoteResponse.type, true),
-                        buyAsset,
-                        sellAsset,
-                        accountNumber,
-                        allowanceContract: '0x0',
-                        estimatedExecutionTimeMs: (singleQuoteResponse.boostQuote.estimatedDurationsSeconds?.deposit ?? 0) +
-                            (singleQuoteResponse.boostQuote.estimatedDurationsSeconds?.swap ?? 0) * 1000,
-                        chainflipSpecific: {
-                            chainflipNumberOfChunks: isStreaming
-                                ? singleQuoteResponse.boostQuote.numberOfChunks ?? undefined
-                                : undefined,
-                            chainflipChunkIntervalBlocks: isStreaming
-                                ? singleQuoteResponse.boostQuote.chunkIntervalBlocks ?? undefined
-                                : undefined,
-                            chainflipMaxBoostFee: getMaxBoostFee(),
-                        },
-                        affiliateFee: buildAffiliateFee({
-                            strategy: 'buy_asset',
-                            affiliateBps: commissionBps,
-                            sellAsset,
-                            buyAsset,
-                            sellAmountCryptoBaseUnit: singleQuoteResponse.boostQuote.ingressAmountNative,
-                            buyAmountCryptoBaseUnit: singleQuoteResponse.boostQuote.egressAmountNative,
-                        }),
-                    },
-                ],
-            };
-            ratesOrQuotes.push(boostTradeRateOrQuote);
-        }
-        const rate = singleQuoteResponse.ingressAmountNative && singleQuoteResponse.egressAmountNative
-            ? getChainflipQuoteRate(singleQuoteResponse.ingressAmountNative, singleQuoteResponse.egressAmountNative)
-            : '0';
-        // This is not really a buyAmount before fees but rather an input/output calculation to get the sell amount
-        // prorated to the buy asset price to determine price impact
-        const buyAmountBeforeFeesCryptoBaseUnit = BigAmount.fromPrecision({
-            value: bnOrZero(singleQuoteResponse.ingressAmount).times(bnOrZero(singleQuoteResponse.estimatedPrice)),
-            precision: buyAsset.precision,
-        }).toBaseUnit();
-        const tradeRateOrQuote = {
-            id: uuid(),
-            rate,
-            receiveAddress,
-            quoteOrRate,
-            affiliateBps: commissionBps,
-            isStreaming,
-            slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal ??
-                getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Chainflip),
-            swapperName: SwapperName.Chainflip,
-            steps: [
-                {
-                    buyAmountBeforeFeesCryptoBaseUnit,
-                    buyAmountAfterFeesCryptoBaseUnit: singleQuoteResponse.egressAmountNative,
-                    sellAmountIncludingProtocolFeesCryptoBaseUnit: singleQuoteResponse.ingressAmountNative,
-                    feeData: {
-                        protocolFees: getProtocolFees(singleQuoteResponse),
-                        ...feeData,
-                    },
-                    rate,
-                    source: getSwapSource(singleQuoteResponse.type, false),
-                    buyAsset,
-                    sellAsset,
-                    accountNumber,
-                    allowanceContract: '0x0',
-                    estimatedExecutionTimeMs: ((singleQuoteResponse.estimatedDurationsSeconds?.deposit ?? 0) +
-                        (singleQuoteResponse.estimatedDurationsSeconds?.swap ?? 0)) *
-                        1000,
-                    chainflipSpecific: {
-                        chainflipNumberOfChunks: isStreaming
-                            ? singleQuoteResponse.numberOfChunks ?? undefined
-                            : undefined,
-                        chainflipChunkIntervalBlocks: isStreaming
-                            ? singleQuoteResponse.chunkIntervalBlocks ?? undefined
-                            : undefined,
-                        chainflipMaxBoostFee: 0,
-                    },
-                    affiliateFee: buildAffiliateFee({
-                        strategy: 'buy_asset',
-                        affiliateBps: commissionBps,
-                        sellAsset,
-                        buyAsset,
-                        sellAmountCryptoBaseUnit: singleQuoteResponse.ingressAmountNative ?? '0',
-                        buyAmountCryptoBaseUnit: singleQuoteResponse.egressAmountNative ?? '0',
-                    }),
-                },
-            ],
-        };
-        ratesOrQuotes.push(tradeRateOrQuote);
-    }
-    return Ok(ratesOrQuotes);
-};

package/dist/esm/swappers/ChainflipSwapper/utils/getUtxoTxFees.d.ts

@@ -1,9 +0,0 @@
-import type { UtxoChainAdapter } from '@shapeshiftoss/chain-adapters';
-import type { QuoteFeeData } from '../../../types.js';
-type GetUtxoTxFeesInput = {
-    sellAmountCryptoBaseUnit: string;
-    sellAdapter: UtxoChainAdapter;
-    pubKey: string | undefined;
-};
-export declare const getUtxoTxFees: ({ sellAmountCryptoBaseUnit, sellAdapter, pubKey, }: GetUtxoTxFeesInput) => Promise<Omit<QuoteFeeData, 'protocolFees'>>;
-export {};

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

@@ -1,21 +0,0 @@
-export const getUtxoTxFees = async ({ sellAmountCryptoBaseUnit, sellAdapter, pubKey, }) => {
-    // Can't do coinselect simulation without a pubkey
-    if (!pubKey)
-        return {
-            networkFeeCryptoBaseUnit: undefined,
-        };
-    const getFeeDataInput = {
-        // One of many vault addresses - just used as a placeholder for the sake of loosely estimating fees - we *need* a *to* address for simulation or this will throw
-        to: 'bc1pfh5x55a3v92klcrdy5yv6yrt7fzr0g929klkdtapp3njfyu4qsyq8qacyf',
-        value: sellAmountCryptoBaseUnit,
-        chainSpecific: { pubkey: pubKey },
-    };
-    const feeDataOptions = await sellAdapter.getFeeData(getFeeDataInput);
-    const feeData = feeDataOptions['fast'];
-    return {
-        networkFeeCryptoBaseUnit: feeData.txFee,
-        chainSpecific: {
-            satsPerByte: feeData.chainSpecific.satoshiPerByte,
-        },
-    };
-};