@shapeshiftoss/swapper 17.8.0 → 18.1.0

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

@@ -1,139 +1,83 @@
-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';
+import { assertQuoteAddresses, makeSwapErrorRight } from '../../../utils/index.js';
+import { getChainflipStepData } from '../utils/getChainflipStepData.js';
+import { getChainflipTradeContexts } from '../utils/getChainflipTradeContexts.js';
+import { calculateChainflipMinPrice, 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 { accountNumber, sellAsset, buyAsset, affiliateBps } = input;
+    const maybeAddresses = assertQuoteAddresses(input);
+    if (maybeAddresses.isErr())
+        return Err(maybeAddresses.unwrapErr());
+    const { sendAddress, receiveAddress } = maybeAddresses.unwrap();
+    const maybeTradeContexts = await getChainflipTradeContexts(input, deps);
+    if (maybeTradeContexts.isErr())
+        return Err(maybeTradeContexts.unwrapErr());
+    const tradeContexts = maybeTradeContexts.unwrap();
+    const tradeQuotes = [];
+    for (const { tradeCommon, stepCommon, protocolFees, stepDataArgs, channelParams, } of tradeContexts) {
+        const minimumPrice = calculateChainflipMinPrice({
+            slippageTolerancePercentageDecimal: tradeCommon.slippageTolerancePercentageDecimal,
+            sellAsset,
+            buyAsset,
+            buyAmountAfterFeesCryptoBaseUnit: channelParams.buyAmountAfterFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit: stepCommon.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        });
+        const maybeSwapResponse = await getChainFlipSwap({
+            brokerUrl,
+            apiKey,
+            sourceAsset: channelParams.sourceAsset,
+            destinationAsset: channelParams.destinationAsset,
+            destinationAddress: receiveAddress,
+            refundAddress: sendAddress,
+            minimumPrice,
+            maxBoostFee: channelParams.maxBoostFee,
+            numberOfChunks: channelParams.numberOfChunks,
+            chunkIntervalBlocks: channelParams.chunkIntervalBlocks,
+            commissionBps: parseInt(affiliateBps),
+        });
+        if (maybeSwapResponse.isErr()) {
+            console.error(maybeSwapResponse.unwrapErr().cause);
+            return Err(makeSwapErrorRight({
+                message: 'Error fetching Chainflip swap',
+                code: TradeQuoteError.UnknownError,
+            }));
         }
-    }
-    const quotesResult = Ok(tradeQuotes);
-    return quotesResult.map(quotes => quotes
-        .map(quote => {
-        if (!quote.receiveAddress) {
-            console.error('receiveAddress is required');
-            return undefined;
+        const { data: swapResponse } = maybeSwapResponse.unwrap();
+        const { address: depositAddress, id: swapId } = swapResponse;
+        if (!swapId || !depositAddress) {
+            return Err(makeSwapErrorRight({
+                message: 'Invalid swap response',
+                code: TradeQuoteError.UnknownError,
+            }));
         }
-        return {
-            ...quote,
+        const maybeStepData = await getChainflipStepData({
+            ...stepDataArgs,
+            type: 'quote',
+            input,
+            depositAddress,
+            from: sendAddress,
+        });
+        if (maybeStepData.isErr())
+            return Err(maybeStepData.unwrapErr());
+        const { transactionData, networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+        tradeQuotes.push({
+            ...tradeCommon,
             quoteOrRate: 'quote',
             receiveAddress,
-            steps: quote.steps.map(step => step),
-        };
-    })
-        .filter(isSome));
+            steps: [
+                {
+                    ...stepCommon,
+                    accountNumber,
+                    chainflipSpecific: { depositAddress },
+                    swapperMetadata: { name: 'chainflip', swapId },
+                    transactionData,
+                    feeData: { networkFeeCryptoBaseUnit, protocolFees },
+                },
+            ],
+        });
+    }
+    return Ok(tradeQuotes);
 };

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

@@ -1,2 +1,4 @@
-import type { GetTradeRateInput, SwapperDeps, TradeRateResult } from '../../../types.js';
-export declare const getTradeRate: (input: GetTradeRateInput, deps: SwapperDeps) => Promise<TradeRateResult>;
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight, SwapperDeps, TradeRate } from '../../../types.js';
+import type { ChainflipTradeRateInput } from '../types.js';
+export declare const getTradeRate: (input: ChainflipTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;

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

@@ -1,9 +1,35 @@
-import { getQuoteOrRate } from '../utils/getQuoteOrRate.js';
+import { Err, Ok } from '@sniptt/monads';
+import { getChainflipStepData } from '../utils/getChainflipStepData.js';
+import { getChainflipTradeContexts } from '../utils/getChainflipTradeContexts.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),
-    })));
+    const { accountNumber } = input;
+    const maybeTradeContexts = await getChainflipTradeContexts(input, deps);
+    if (maybeTradeContexts.isErr())
+        return Err(maybeTradeContexts.unwrapErr());
+    const tradeContexts = maybeTradeContexts.unwrap();
+    const tradeRates = [];
+    for (const { tradeCommon, stepCommon, protocolFees, stepDataArgs } of tradeContexts) {
+        const maybeStepData = await getChainflipStepData({
+            ...stepDataArgs,
+            type: 'rate',
+            input,
+            from: input.sendAddress,
+        });
+        if (maybeStepData.isErr())
+            return Err(maybeStepData.unwrapErr());
+        const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+        tradeRates.push({
+            ...tradeCommon,
+            quoteOrRate: 'rate',
+            receiveAddress: input.receiveAddress,
+            steps: [
+                {
+                    ...stepCommon,
+                    accountNumber,
+                    feeData: { networkFeeCryptoBaseUnit, protocolFees },
+                },
+            ],
+        });
+    }
+    return Ok(tradeRates);
 };

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

@@ -1,5 +1,12 @@
+import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput, GetSolanaTradeQuoteInput, GetSolanaTradeRateInput, GetTronTradeQuoteInput, GetTronTradeRateInput, GetUtxoTradeQuoteInput, GetUtxoTradeRateInput } from '../../types.js';
 import type { ChainflipBaasStatusEgress } from './models/ChainflipBaasStatusEgress.js';
 import type { ChainflipBaasStatusSwap } from './models/ChainflipBaasStatusSwap.js';
+export type ChainflipTradeQuoteInput = GetEvmTradeQuoteInput | GetUtxoTradeQuoteInput | GetSolanaTradeQuoteInput | GetTronTradeQuoteInput;
+export type ChainflipTradeRateInput = GetEvmTradeRateInput | GetUtxoTradeRateInput | GetSolanaTradeRateInput | GetTronTradeRateInput;
+export type ChainflipMetadata = {
+    name: 'chainflip';
+    swapId: number | string;
+};
 export type ChainFlipStatus = {
     status: {
         state: 'waiting' | 'receiving' | 'swapping' | 'sending' | 'sent' | 'completed' | 'failed';

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

@@ -1,4 +1,4 @@
-import { createCache, makeSwapperAxiosServiceMonadic } from '../../../utils.js';
+import { createCache, makeSwapperAxiosServiceMonadic } from '../../../utils/index.js';
 const maxAge = 15 * 1000; // 15 seconds ttl for all except cached to get fresh status updates
 const cachedUrls = ['/assets/'];
 const axiosConfig = {

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

@@ -0,0 +1,26 @@
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.js';
+import type { SolanaComputeBudgetOptions } from '../../../utils/solana/index.js';
+export declare const CHAINFLIP_SOLANA_COMPUTE_BUDGET: SolanaComputeBudgetOptions;
+type BaseArgs = {
+    sellAmountCryptoBaseUnit: string;
+};
+export type GetChainflipStepDataArgs = StepDataArgs<BaseArgs, {
+    depositAddress?: undefined;
+}, {
+    depositAddress: string;
+}>;
+type ChainflipRateStepData = {
+    networkFeeCryptoBaseUnit: string | undefined;
+};
+type ChainflipQuoteStepData = {
+    transactionData?: TxBuildData;
+    networkFeeCryptoBaseUnit: string | undefined;
+};
+export declare function getChainflipStepData(args: Extract<GetChainflipStepDataArgs, {
+    type: 'rate';
+}>): Promise<Result<ChainflipRateStepData, SwapErrorRight>>;
+export declare function getChainflipStepData(args: Extract<GetChainflipStepDataArgs, {
+    type: 'quote';
+}>): Promise<Result<ChainflipQuoteStepData, SwapErrorRight>>;
+export {};

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

@@ -0,0 +1,182 @@
+import { CHAIN_NAMESPACE, fromAssetId, fromChainId } from '@shapeshiftoss/caip';
+import { evm } from '@shapeshiftoss/chain-adapters';
+import { bn, contractAddressOrUndefined } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { TradeQuoteError } from '../../../types.js';
+import { makeNetworkFeeEstimationFailedErr, makeSwapErrorRight } from '../../../utils/index.js';
+import { getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
+import { isNativeEvmAsset } from '../../../utils/helpers.js';
+import { ATA_RENT_LAMPORTS, getSolanaNetworkFeeCryptoBaseUnit, SOLANA_PLACEHOLDER_ADDRESS, withComputeUnitLimit, } from '../../../utils/solana/index.js';
+import { getUtxoNetworkFeeCryptoBaseUnit, UTXO_PLACEHOLDER_ADDRESS } from '../../../utils/utxo/index.js';
+// Deposits are plain transfers - 21k intrinsic for natives, tokens measured ~50-65k to a fresh
+// deposit address across the supported set (usdc/usdt/flip)
+const SAFE_NATIVE_TRANSFER_GAS_LIMIT = '21000';
+const SAFE_TOKEN_TRANSFER_GAS_LIMIT = '65000';
+// Deposits are plain (token) transfers with constant measured compute consumption (max 15394 CU
+// with ata creation), so the margin is safety only; the floor guarantees the limit covers full
+// ata recreation if the deposit ata is closed between simulation and landing (a no-op create
+// simulates ~3x cheaper than a real one)
+export const CHAINFLIP_SOLANA_COMPUTE_BUDGET = {
+    marginMultiplier: 1.1,
+    minComputeUnits: 20_000,
+};
+export async function getChainflipStepData(args) {
+    const { deps, type, input, sellAsset, sellAmountCryptoBaseUnit, depositAddress, from } = args;
+    const { chainNamespace } = fromAssetId(sellAsset.assetId);
+    switch (chainNamespace) {
+        case CHAIN_NAMESPACE.Evm: {
+            const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+            const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
+            if (type === 'rate') {
+                try {
+                    const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+                        adapter,
+                        supportsEIP1559,
+                        gasLimit: isNativeEvmAsset(sellAsset.assetId)
+                            ? SAFE_NATIVE_TRANSFER_GAS_LIMIT
+                            : SAFE_TOKEN_TRANSFER_GAS_LIMIT,
+                    });
+                    const stepData = { networkFeeCryptoBaseUnit };
+                    return Ok(stepData);
+                }
+                catch (error) {
+                    return Err(makeNetworkFeeEstimationFailedErr('getChainflipStepData', error));
+                }
+            }
+            const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
+            const data = evm.getErc20Data(depositAddress, sellAmountCryptoBaseUnit, contractAddress);
+            const transactionData = {
+                type: 'evm',
+                chainId: Number(fromChainId(sellAsset.chainId).chainReference),
+                to: contractAddress ?? depositAddress,
+                data: data || '0x',
+                value: isNativeEvmAsset(sellAsset.assetId) ? sellAmountCryptoBaseUnit : '0',
+            };
+            try {
+                // The deposit is a plain (token) transfer with no approval involved, but estimation
+                // still reverts for an unfunded sender - override the missing balance only
+                const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+                    adapter,
+                    transactionData,
+                    from,
+                    supportsEIP1559,
+                    stateOverride: { sellAsset, sellAmountCryptoBaseUnit },
+                });
+                const stepData = { transactionData, networkFeeCryptoBaseUnit };
+                return Ok(stepData);
+            }
+            catch (error) {
+                return Err(makeNetworkFeeEstimationFailedErr('getChainflipStepData', error));
+            }
+        }
+        case CHAIN_NAMESPACE.Utxo: {
+            const adapter = deps.assertGetUtxoChainAdapter(sellAsset.chainId);
+            try {
+                const { networkFeeCryptoBaseUnit } = await getUtxoNetworkFeeCryptoBaseUnit({
+                    adapter,
+                    pubkey: 'xpub' in input ? input.xpub : undefined,
+                    to: depositAddress ?? UTXO_PLACEHOLDER_ADDRESS,
+                    value: sellAmountCryptoBaseUnit,
+                });
+                if (type === 'rate') {
+                    const stepData = { networkFeeCryptoBaseUnit };
+                    return Ok(stepData);
+                }
+                const transactionData = {
+                    type: 'utxo',
+                    to: depositAddress,
+                    value: sellAmountCryptoBaseUnit,
+                };
+                const stepData = { transactionData, networkFeeCryptoBaseUnit };
+                return Ok(stepData);
+            }
+            catch (error) {
+                return Err(makeNetworkFeeEstimationFailedErr('getChainflipStepData', error));
+            }
+        }
+        case CHAIN_NAMESPACE.Solana: {
+            const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+            const tokenId = contractAddressOrUndefined(sellAsset.assetId);
+            try {
+                if (type === 'rate') {
+                    // No deposit channel yet - estimate via a self transfer (placeholder sender when walletless),
+                    // plus static ATA rent for token sells since the transfer omits the deposit ATA creation
+                    const address = from ?? SOLANA_PLACEHOLDER_ADDRESS;
+                    const instructions = await adapter.buildTransferInstructions({
+                        from: address,
+                        to: address,
+                        tokenId: from ? tokenId : undefined,
+                        value: from ? sellAmountCryptoBaseUnit : '1',
+                    });
+                    const { networkFeeCryptoBaseUnit } = await getSolanaNetworkFeeCryptoBaseUnit({
+                        adapter,
+                        from: address,
+                        instructions,
+                        tokenId,
+                    });
+                    const stepData = {
+                        networkFeeCryptoBaseUnit: bn(networkFeeCryptoBaseUnit)
+                            .plus(tokenId ? ATA_RENT_LAMPORTS : 0)
+                            .toString(),
+                    };
+                    return Ok(stepData);
+                }
+                const instructions = await adapter.buildTransferInstructions({
+                    from,
+                    to: depositAddress,
+                    tokenId,
+                    value: sellAmountCryptoBaseUnit,
+                });
+                const { networkFeeCryptoBaseUnit, feeData, includeComputeBudget } = await getSolanaNetworkFeeCryptoBaseUnit({
+                    adapter,
+                    from,
+                    instructions,
+                    tokenId,
+                });
+                const transactionData = {
+                    type: 'solana_instructions',
+                    instructions: withComputeUnitLimit({
+                        instructions,
+                        computeUnits: feeData.chainSpecific.computeUnits,
+                        includeComputeBudget,
+                        computeBudget: CHAINFLIP_SOLANA_COMPUTE_BUDGET,
+                    }),
+                    addressLookupTableAddresses: [],
+                };
+                const stepData = { transactionData, networkFeeCryptoBaseUnit };
+                return Ok(stepData);
+            }
+            catch (error) {
+                return Err(makeNetworkFeeEstimationFailedErr('getChainflipStepData', error));
+            }
+        }
+        // Un-migrated - exec builds its tx from chainflipSpecific.depositAddress, so no transactionData is carried
+        case CHAIN_NAMESPACE.Tron: {
+            const to = depositAddress ?? from;
+            if (!to || !from) {
+                const stepData = { networkFeeCryptoBaseUnit: undefined };
+                return Ok(stepData);
+            }
+            try {
+                const { fast } = await deps.assertGetTronChainAdapter(sellAsset.chainId).getFeeData({
+                    to,
+                    value: sellAmountCryptoBaseUnit,
+                    chainSpecific: {
+                        from,
+                        contractAddress: contractAddressOrUndefined(sellAsset.assetId),
+                    },
+                });
+                const stepData = { networkFeeCryptoBaseUnit: fast.txFee };
+                return Ok(stepData);
+            }
+            catch (error) {
+                return Err(makeNetworkFeeEstimationFailedErr('getChainflipStepData', error));
+            }
+        }
+        default:
+            return Err(makeSwapErrorRight({
+                message: `[getChainflipStepData] unsupported chainNamespace: ${chainNamespace}`,
+                code: TradeQuoteError.UnsupportedChain,
+            }));
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types.js';
+import type { ChainflipTradeQuoteInput, ChainflipTradeRateInput } from '../types.js';
+import type { GetChainflipStepDataArgs } from './getChainflipStepData.js';
+export type ChainflipTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    stepDataArgs: Omit<GetChainflipStepDataArgs, 'type' | 'input' | 'depositAddress' | 'from'>;
+    channelParams: {
+        sourceAsset: string;
+        destinationAsset: string;
+        maxBoostFee: number;
+        numberOfChunks: number | undefined;
+        chunkIntervalBlocks: number | undefined;
+        buyAmountAfterFeesCryptoBaseUnit: string;
+    };
+};
+export declare const getChainflipTradeContexts: (input: ChainflipTradeQuoteInput | ChainflipTradeRateInput, deps: SwapperDeps) => Promise<Result<ChainflipTradeContext[], SwapErrorRight>>;

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

@@ -0,0 +1,137 @@
+import { 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, makeSwapErrorRight } from '../../../utils/index.js';
+import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
+import { CHAINFLIP_DCA_QUOTE } from '../constants.js';
+import { chainflipService } from './chainflipService.js';
+import { assertValidTrade, getChainFlipIdFromAssetId, getChainflipRate, getMaxBoostFee, getProtocolFees, getSwapSource, } from './helpers.js';
+export const getChainflipTradeContexts = async (input, deps) => {
+    const brokerUrl = deps.config.VITE_CHAINFLIP_API_URL;
+    const apiKey = deps.config.VITE_CHAINFLIP_API_KEY;
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const assertion = assertValidTrade({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const maybeSourceAsset = await getChainFlipIdFromAssetId({
+        assetId: sellAsset.assetId,
+        brokerUrl,
+    });
+    if (maybeSourceAsset.isErr())
+        return Err(maybeSourceAsset.unwrapErr());
+    const sourceAsset = maybeSourceAsset.unwrap();
+    const maybeDestinationAsset = await getChainFlipIdFromAssetId({
+        assetId: buyAsset.assetId,
+        brokerUrl,
+    });
+    if (maybeDestinationAsset.isErr())
+        return Err(maybeDestinationAsset.unwrapErr());
+    const destinationAsset = maybeDestinationAsset.unwrap();
+    const maybeQuoteResponse = await chainflipService.get(`${brokerUrl}/quotes-native` +
+        `?apiKey=${apiKey}` +
+        `&sourceAsset=${sourceAsset}` +
+        `&destinationAsset=${destinationAsset}` +
+        `&amount=${sellAmountIncludingProtocolFeesCryptoBaseUnit}` +
+        `&commissionBps=${parseInt(affiliateBps)}`);
+    if (maybeQuoteResponse.isErr()) {
+        const error = maybeQuoteResponse.unwrapErr();
+        const cause = error.cause;
+        const minAmountCryptoBaseUnit = cause?.response?.data?.errors?.minimalAmountNative?.[0];
+        if (cause?.response?.status === 400 && minAmountCryptoBaseUnit !== undefined) {
+            return Err(createTradeAmountTooSmallErr({ assetId: sellAsset.assetId, minAmountCryptoBaseUnit }));
+        }
+        return Err(makeSwapErrorRight({ message: 'Quote request failed', code: TradeQuoteError.NoRouteFound }));
+    }
+    const { data: quotes } = maybeQuoteResponse.unwrap();
+    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
+        getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Chainflip);
+    const tradeContexts = [];
+    for (const quote of quotes) {
+        if (!quote.type) {
+            return Err(makeSwapErrorRight({
+                message: '[getChainflipTradeContext] Missing quote type',
+                code: TradeQuoteError.InvalidResponse,
+            }));
+        }
+        const quoteType = quote.type;
+        const isStreaming = quoteType === CHAINFLIP_DCA_QUOTE;
+        if (isStreaming && !deps.config.VITE_FEATURE_CHAINFLIP_SWAP_DCA)
+            continue;
+        // estimatedPrice and type only exist on the parent quote, not the boost variant
+        const buildTradeContext = (variantQuote, isBoosted) => {
+            const rate = getChainflipRate({
+                sellAmountCryptoBaseUnit: variantQuote.ingressAmountNative,
+                buyAmountCryptoBaseUnit: variantQuote.egressAmountNative,
+                sellAsset,
+                buyAsset,
+            });
+            const buyAmountAfterFeesCryptoBaseUnit = variantQuote.egressAmountNative ?? '0';
+            const variantSellAmountCryptoBaseUnit = variantQuote.ingressAmountNative ?? '0';
+            const streamingChunkValue = (value) => isStreaming ? value ?? undefined : undefined;
+            const protocolFees = getProtocolFees({
+                quote: variantQuote,
+                sellAsset,
+                buyAsset,
+                sourceAsset,
+                destinationAsset,
+            });
+            return {
+                tradeCommon: {
+                    id: uuid(),
+                    rate,
+                    affiliateBps,
+                    isStreaming,
+                    slippageTolerancePercentageDecimal,
+                    swapperName: SwapperName.Chainflip,
+                },
+                stepCommon: {
+                    // Not a real pre-fee amount, but an input/output calc prorated to the buy asset price to determine price impact
+                    buyAmountBeforeFeesCryptoBaseUnit: BigAmount.fromPrecision({
+                        value: bnOrZero(variantQuote.ingressAmount).times(bnOrZero(quote.estimatedPrice)),
+                        precision: buyAsset.precision,
+                    }).toBaseUnit(),
+                    buyAmountAfterFeesCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit: variantSellAmountCryptoBaseUnit,
+                    rate,
+                    source: getSwapSource(quoteType, isBoosted),
+                    buyAsset,
+                    sellAsset,
+                    allowanceContract: '',
+                    estimatedExecutionTimeMs: ((variantQuote.estimatedDurationsSeconds?.deposit ?? 0) +
+                        (variantQuote.estimatedDurationsSeconds?.swap ?? 0)) *
+                        1000,
+                    affiliateFee: buildAffiliateFee({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: variantSellAmountCryptoBaseUnit,
+                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                    }),
+                },
+                protocolFees,
+                stepDataArgs: {
+                    deps,
+                    sellAsset,
+                    sellAmountCryptoBaseUnit: variantSellAmountCryptoBaseUnit,
+                },
+                channelParams: {
+                    sourceAsset,
+                    destinationAsset,
+                    maxBoostFee: isBoosted ? getMaxBoostFee(sellAsset.assetId) : 0,
+                    numberOfChunks: streamingChunkValue(variantQuote.numberOfChunks),
+                    chunkIntervalBlocks: streamingChunkValue(variantQuote.chunkIntervalBlocks),
+                    buyAmountAfterFeesCryptoBaseUnit,
+                },
+            };
+        };
+        const { boostQuote } = quote;
+        if (boostQuote && boostQuote.ingressAmountNative && boostQuote.egressAmountNative) {
+            tradeContexts.push(buildTradeContext(boostQuote, true));
+        }
+        tradeContexts.push(buildTradeContext(quote, false));
+    }
+    return Ok(tradeContexts);
+};