@shapeshiftoss/swapper 17.6.6 → 17.6.8

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

@@ -0,0 +1,52 @@
+// @ts-nocheck
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Chainflip Broker as a Service
+ * Run your own Chainflip Broker without any hassle.
+ *
+ * The version of the OpenAPI document: v1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { exists } from '../runtime';
+/**
+ * Check if a given object implements the ChainflipBaasSwapDepositAddress interface.
+ */
+export function instanceOfChainflipBaasSwapDepositAddress(value) {
+    let isInstance = true;
+    return isInstance;
+}
+export function ChainflipBaasSwapDepositAddressFromJSON(json) {
+    return ChainflipBaasSwapDepositAddressFromJSONTyped(json, false);
+}
+export function ChainflipBaasSwapDepositAddressFromJSONTyped(json, ignoreDiscriminator) {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        'id': !exists(json, 'id') ? undefined : json['id'],
+        'address': !exists(json, 'address') ? undefined : json['address'],
+        'issuedBlock': !exists(json, 'issuedBlock') ? undefined : json['issuedBlock'],
+        'network': !exists(json, 'network') ? undefined : json['network'],
+        'channelId': !exists(json, 'channelId') ? undefined : json['channelId'],
+        'sourceExpiryBlock': !exists(json, 'sourceExpiryBlock') ? undefined : json['sourceExpiryBlock'],
+        'explorerUrl': !exists(json, 'explorerUrl') ? undefined : json['explorerUrl'],
+        'channelOpeningFee': !exists(json, 'channelOpeningFee') ? undefined : json['channelOpeningFee'],
+        'channelOpeningFeeNative': !exists(json, 'channelOpeningFeeNative') ? undefined : json['channelOpeningFeeNative'],
+    };
+}
+export function ChainflipBaasSwapDepositAddressToJSON(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        'id': value.id,
+    };
+}

package/dist/esm/swappers/ChainflipSwapper/models/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ChainflipBaasQuoteQuote.js';
+export * from './ChainflipBaasQuoteQuoteFee.js';
+export * from './ChainflipBaasSwapDepositAddress.js';

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

@@ -0,0 +1,3 @@
+export * from './ChainflipBaasQuoteQuote.js';
+export * from './ChainflipBaasQuoteQuoteFee.js';
+export * from './ChainflipBaasSwapDepositAddress.js';

package/dist/esm/swappers/ChainflipSwapper/swapperApi/getTradeQuote.d.ts

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

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

@@ -0,0 +1,139 @@
+import { CHAIN_NAMESPACE, fromAssetId, solAssetId } from '@shapeshiftoss/caip';
+import { isSome } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils.js';
+import { getQuoteOrRate } from '../utils/getQuoteOrRate.js';
+import { calculateChainflipMinPrice, getChainFlipIdFromAssetId, getChainFlipSwap, } from '../utils/helpers.js';
+export const getTradeQuote = async (input, deps) => {
+    const { sellAsset, buyAsset, accountNumber, sendAddress, receiveAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, } = input;
+    if (accountNumber === undefined) {
+        return Err(makeSwapErrorRight({
+            message: `accountNumber is required`,
+            code: TradeQuoteError.UnknownError,
+        }));
+    }
+    if (sendAddress === undefined) {
+        return Err(makeSwapErrorRight({
+            message: `sendAddress is required`,
+            code: TradeQuoteError.UnknownError,
+        }));
+    }
+    if (receiveAddress === undefined) {
+        return Err(makeSwapErrorRight({
+            message: `receiveAddress is required`,
+            code: TradeQuoteError.UnknownError,
+        }));
+    }
+    const maybeTradeQuotes = await getQuoteOrRate(input, deps);
+    if (maybeTradeQuotes.isErr())
+        return Err(maybeTradeQuotes.unwrapErr());
+    const brokerUrl = deps.config.VITE_CHAINFLIP_API_URL;
+    const apiKey = deps.config.VITE_CHAINFLIP_API_KEY;
+    const tradeQuotes = maybeTradeQuotes.unwrap();
+    // We need to open a deposit channel at this point to attach the swap id to the quote,
+    // in order to properly fetch the streaming status later
+    for (const tradeQuote of tradeQuotes) {
+        for (const step of tradeQuote.steps) {
+            const maybeSourceAsset = await getChainFlipIdFromAssetId({
+                assetId: sellAsset.assetId,
+                brokerUrl,
+            });
+            const maybeDestinationAsset = await getChainFlipIdFromAssetId({
+                assetId: buyAsset.assetId,
+                brokerUrl,
+            });
+            if (maybeDestinationAsset.isErr())
+                return Err(maybeDestinationAsset.unwrapErr());
+            if (maybeSourceAsset.isErr())
+                return Err(maybeSourceAsset.unwrapErr());
+            const destinationAsset = maybeDestinationAsset.unwrap();
+            const sourceAsset = maybeSourceAsset.unwrap();
+            const minimumPrice = calculateChainflipMinPrice({
+                slippageTolerancePercentageDecimal: tradeQuote.slippageTolerancePercentageDecimal,
+                sellAsset,
+                buyAsset,
+                buyAmountAfterFeesCryptoBaseUnit: step.buyAmountAfterFeesCryptoBaseUnit,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            });
+            const serviceCommission = parseInt(tradeQuote.affiliateBps);
+            const maybeSwapResponse = await getChainFlipSwap({
+                brokerUrl,
+                apiKey,
+                sourceAsset,
+                minimumPrice,
+                destinationAsset,
+                destinationAddress: receiveAddress,
+                refundAddress: sendAddress,
+                maxBoostFee: step.chainflipSpecific?.chainflipMaxBoostFee,
+                numberOfChunks: step.chainflipSpecific?.chainflipNumberOfChunks,
+                chunkIntervalBlocks: step.chainflipSpecific?.chainflipChunkIntervalBlocks,
+                commissionBps: serviceCommission,
+            });
+            if (maybeSwapResponse.isErr()) {
+                const error = maybeSwapResponse.unwrapErr();
+                const cause = error.cause;
+                console.error(cause);
+                return Err(makeSwapErrorRight({
+                    message: `Error fetching Chainflip swap`,
+                    code: TradeQuoteError.UnknownError,
+                }));
+            }
+            const { data: swapResponse } = maybeSwapResponse.unwrap();
+            if (!swapResponse.id)
+                throw Error('Missing Swap Id');
+            if (!swapResponse.address)
+                throw Error('Missing Deposit Channel');
+            const depositAddress = swapResponse.address;
+            const getFeeData = async () => {
+                const { chainNamespace } = fromAssetId(sellAsset.assetId);
+                // We faked feeData for Solana with a self-send during rates, we can now properly do it on quote time
+                switch (chainNamespace) {
+                    case CHAIN_NAMESPACE.Solana: {
+                        const sellAdapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+                        const getFeeDataInput = {
+                            to: depositAddress,
+                            value: sellAmount,
+                            chainSpecific: {
+                                from: sendAddress,
+                                tokenId: sellAsset.assetId === solAssetId
+                                    ? undefined
+                                    : fromAssetId(sellAsset.assetId).assetReference,
+                            },
+                        };
+                        const { fast } = await sellAdapter.getFeeData(getFeeDataInput);
+                        return {
+                            protocolFees: step.feeData.protocolFees,
+                            networkFeeCryptoBaseUnit: fast.txFee,
+                        };
+                    }
+                    default:
+                        return step.feeData;
+                }
+            };
+            if (!step.chainflipSpecific)
+                step.chainflipSpecific = {
+                    chainflipSwapId: swapResponse.id,
+                    chainflipDepositAddress: depositAddress,
+                };
+            step.chainflipSpecific.chainflipSwapId = swapResponse.id;
+            step.chainflipSpecific.chainflipDepositAddress = swapResponse.address;
+            step.feeData = await getFeeData();
+        }
+    }
+    const quotesResult = Ok(tradeQuotes);
+    return quotesResult.map(quotes => quotes
+        .map(quote => {
+        if (!quote.receiveAddress) {
+            console.error('receiveAddress is required');
+            return undefined;
+        }
+        return {
+            ...quote,
+            quoteOrRate: 'quote',
+            receiveAddress,
+            steps: quote.steps.map(step => step),
+        };
+    })
+        .filter(isSome));
+};

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

@@ -0,0 +1,2 @@
+import type { GetTradeRateInput, SwapperDeps, TradeRateResult } from '../../../types.js';
+export declare const getTradeRate: (input: GetTradeRateInput, deps: SwapperDeps) => Promise<TradeRateResult>;

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

@@ -0,0 +1,9 @@
+import { getQuoteOrRate } from '../utils/getQuoteOrRate.js';
+export const getTradeRate = async (input, deps) => {
+    const ratesResult = await getQuoteOrRate(input, deps);
+    return ratesResult.map(rates => rates.map(rate => ({
+        ...rate,
+        quoteOrRate: 'rate',
+        steps: rate.steps.map(step => step),
+    })));
+};

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

@@ -0,0 +1,15 @@
+import type { ChainflipBaasStatusEgress } from './models/ChainflipBaasStatusEgress.js';
+import type { ChainflipBaasStatusSwap } from './models/ChainflipBaasStatusSwap.js';
+export type ChainFlipStatus = {
+    status: {
+        state: 'waiting' | 'receiving' | 'swapping' | 'sending' | 'sent' | 'completed' | 'failed';
+        swap?: ChainflipBaasStatusSwap;
+        swapEgress?: ChainflipBaasStatusEgress;
+    };
+};
+export declare enum ChainflipNetwork {
+    Bitcoin = "Bitcoin",
+    Ethereum = "Ethereum",
+    Arbitrum = "Arbitrum",
+    Solana = "Solana"
+}

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

@@ -0,0 +1,7 @@
+export var ChainflipNetwork;
+(function (ChainflipNetwork) {
+    ChainflipNetwork["Bitcoin"] = "Bitcoin";
+    ChainflipNetwork["Ethereum"] = "Ethereum";
+    ChainflipNetwork["Arbitrum"] = "Arbitrum";
+    ChainflipNetwork["Solana"] = "Solana";
+})(ChainflipNetwork || (ChainflipNetwork = {}));

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

@@ -0,0 +1,5 @@
+export declare const chainflipService: {
+    get: <T = any>(url: string, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    post: <T_1 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_1, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    delete: <T_2 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_2, any, {}>, import("../../../index.js").SwapErrorRight>>;
+};

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

@@ -0,0 +1,12 @@
+import { createCache, makeSwapperAxiosServiceMonadic } from '../../../utils.js';
+const maxAge = 15 * 1000; // 15 seconds ttl for all except cached to get fresh status updates
+const cachedUrls = ['/assets/'];
+const axiosConfig = {
+    timeout: 10000,
+    headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+    },
+};
+const chainflipServiceBase = createCache(maxAge, cachedUrls, axiosConfig);
+export const chainflipService = makeSwapperAxiosServiceMonadic(chainflipServiceBase);

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

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

@@ -0,0 +1,11 @@
+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/getLatestChainflipStatusMessage.d.ts

@@ -0,0 +1,2 @@
+import type { ChainFlipStatus } from '../types.js';
+export declare const getLatestChainflipStatusMessage: (status: ChainFlipStatus) => string;

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

@@ -0,0 +1,24 @@
+import { ChainflipStatusMessage } from '../constants.js';
+export const getLatestChainflipStatusMessage = (status) => {
+    const { state, swapEgress } = status.status;
+    switch (state) {
+        case 'waiting':
+            return ChainflipStatusMessage.WaitingForDeposit;
+        case 'receiving':
+            return ChainflipStatusMessage.DepositDetected;
+        case 'swapping':
+            return ChainflipStatusMessage.ProcessingSwap;
+        case 'sent':
+            return ChainflipStatusMessage.TransactionSent;
+        case 'sending':
+            return swapEgress?.transactionReference
+                ? ChainflipStatusMessage.OutboundTransactionInitiated
+                : ChainflipStatusMessage.PreparingOutboundTransaction;
+        case 'completed':
+            return ChainflipStatusMessage.SwapComplete;
+        case 'failed':
+            return ChainflipStatusMessage.SwapFailed;
+        default:
+            return 'Unknown status';
+    }
+};

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

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

@@ -0,0 +1,293 @@
+import { CHAIN_NAMESPACE, fromAssetId, solAssetId } from '@shapeshiftoss/caip';
+import { assertUnreachable, bnOrZero, toBaseUnit } 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 { 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 = toBaseUnit(bnOrZero(singleQuoteResponse.boostQuote.ingressAmount).times(bnOrZero(singleQuoteResponse.estimatedPrice)), buyAsset.precision);
+            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(),
+                        },
+                    },
+                ],
+            };
+            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 = toBaseUnit(bnOrZero(singleQuoteResponse.ingressAmount).times(bnOrZero(singleQuoteResponse.estimatedPrice)), buyAsset.precision);
+        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,
+                    },
+                },
+            ],
+        };
+        ratesOrQuotes.push(tradeRateOrQuote);
+    }
+    return Ok(ratesOrQuotes);
+};

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

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

@@ -0,0 +1,21 @@
+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,
+        },
+    };
+};