@shapeshiftoss/swapper 17.8.0 → 19.0.0

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

@@ -1,181 +1,34 @@
-import { evm } from '@shapeshiftoss/chain-adapters';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
 import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
-import { getTronTransactionFees } from '../../tron-utils/getTronTransactionFees.js';
-import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
-import { isNativeEvmAsset } from '../utils/helpers/helpers.js';
+import { getExecutableTradeStep, getSwapMetadata, isExecutableTradeQuote } from '../../utils/index.js';
+import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
+import { getSolanaTransactionFees, getUnsignedSolanaTransaction } from '../../utils/solana/index.js';
+import { getTronTransactionFees } from '../../utils/tron/index.js';
+import { getUnsignedUtxoTransaction, getUtxoTransactionFees } from '../../utils/utxo/index.js';
 import { ChainflipStatusMessage } from './constants.js';
 import { getTradeQuote } from './swapperApi/getTradeQuote.js';
 import { getTradeRate } from './swapperApi/getTradeRate.js';
 import { chainflipService } from './utils/chainflipService.js';
 import { getLatestChainflipStatusMessage } from './utils/getLatestChainflipStatusMessage.js';
 export const chainflipApi = {
-    getTradeQuote,
-    getTradeRate,
-    getUnsignedEvmTransaction: async ({ from, stepIndex, tradeQuote, assertGetEvmChainAdapter, supportsEIP1559, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { accountNumber, chainflipSpecific, sellAsset } = step;
-        if (!chainflipSpecific?.chainflipDepositAddress)
-            throw Error('Missing deposit address');
-        if (!chainflipSpecific?.chainflipSwapId)
-            throw Error('Missing swap id');
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        const to = chainflipSpecific.chainflipDepositAddress;
-        const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
-        const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
-        const data = evm.getErc20Data(to, value, contractAddress);
-        const feeData = await evm.getFees({
-            adapter,
-            data: data || '0x',
-            to: contractAddress ?? to,
-            value: isNativeEvmAsset(sellAsset.assetId) ? value : '0',
-            from,
-            supportsEIP1559,
-        });
-        return adapter.buildSendApiTransaction({
-            accountNumber,
-            from,
-            to,
-            value,
-            chainSpecific: { contractAddress, ...feeData },
-        });
-    },
-    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { chainflipSpecific, sellAsset } = step;
-        if (!chainflipSpecific?.chainflipDepositAddress)
-            throw Error('Missing deposit address');
-        if (!chainflipSpecific?.chainflipSwapId)
-            throw Error('Missing swap id');
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
-        const to = chainflipSpecific.chainflipDepositAddress;
-        const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
-        const data = evm.getErc20Data(to, value, contractAddress);
-        const { networkFeeCryptoBaseUnit } = await evm.getFees({
-            adapter,
-            data: data || '0x',
-            to: contractAddress ?? to,
-            value: isNativeEvmAsset(sellAsset.assetId) ? value : '0',
-            from,
-            supportsEIP1559,
-        });
-        return networkFeeCryptoBaseUnit;
-    },
-    getUnsignedUtxoTransaction: ({ stepIndex, tradeQuote, xpub, accountType, assertGetUtxoChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { accountNumber, chainflipSpecific, sellAsset } = step;
-        if (!chainflipSpecific?.chainflipDepositAddress)
-            throw Error('Missing deposit address');
-        if (!chainflipSpecific?.chainflipSwapId)
-            throw Error('Missing swap id');
-        const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
-        return adapter.buildSendApiTransaction({
-            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            xpub,
-            to: chainflipSpecific.chainflipDepositAddress,
-            accountNumber,
-            skipToAddressValidation: true,
-            chainSpecific: {
-                accountType,
-                satoshiPerByte: step.feeData.chainSpecific.satsPerByte,
-            },
-        });
-    },
-    getUtxoTransactionFees: async ({ stepIndex, tradeQuote, xpub, assertGetUtxoChainAdapter }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { chainflipSpecific, sellAsset } = step;
-        if (!chainflipSpecific?.chainflipDepositAddress)
-            throw Error('Missing deposit address');
-        if (!chainflipSpecific?.chainflipSwapId)
-            throw Error('Missing swap id');
-        const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
-        const { fast } = await adapter.getFeeData({
-            to: chainflipSpecific.chainflipDepositAddress,
-            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            chainSpecific: { pubkey: xpub },
-            sendMax: false,
-        });
-        return fast.txFee;
-    },
-    getUnsignedSolanaTransaction: async ({ stepIndex, tradeQuote, from, assertGetSolanaChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { accountNumber, chainflipSpecific, sellAsset } = step;
-        if (!chainflipSpecific?.chainflipDepositAddress)
-            throw Error('Missing deposit address');
-        if (!chainflipSpecific?.chainflipSwapId)
-            throw Error('Missing swap id');
-        const adapter = assertGetSolanaChainAdapter(sellAsset.chainId);
-        const to = chainflipSpecific.chainflipDepositAddress;
-        const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
-        const tokenId = contractAddressOrUndefined(sellAsset.assetId);
-        const { fast } = await adapter.getFeeData({
-            to,
-            value,
-            chainSpecific: { from, tokenId },
-        });
-        // Chainflip deposit addresses are program-owned accounts that require more compute
-        // than a regular SOL transfer. Apply a safety margin to avoid "Computational budget exceeded".
-        const computeUnits = Math.ceil(Math.max(Number(fast.chainSpecific.computeUnits), 50_000) * 1.6);
-        return adapter.buildSendApiTransaction({
-            to,
-            from,
-            value,
-            accountNumber,
-            chainSpecific: {
-                tokenId,
-                computeUnitLimit: String(computeUnits),
-                computeUnitPrice: fast.chainSpecific.priorityFee,
-            },
-        });
-    },
-    getSolanaTransactionFees: async ({ stepIndex, tradeQuote, from, assertGetSolanaChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { chainflipSpecific, sellAsset } = step;
-        if (!chainflipSpecific?.chainflipDepositAddress)
-            throw Error('Missing deposit address');
-        if (!chainflipSpecific?.chainflipSwapId)
-            throw Error('Missing swap id');
-        const adapter = assertGetSolanaChainAdapter(sellAsset.chainId);
-        const { fast } = await adapter.getFeeData({
-            to: chainflipSpecific.chainflipDepositAddress,
-            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            chainSpecific: {
-                from,
-                tokenId: contractAddressOrUndefined(sellAsset.assetId),
-            },
-        });
-        // Mirror the same compute budget boost as getUnsignedSolanaTransaction
-        // to avoid underquoting fees for Chainflip deposit addresses
-        const simulatedUnits = Number(fast.chainSpecific.computeUnits);
-        const boostedUnits = Math.ceil(Math.max(simulatedUnits, 50_000) * 1.6);
-        const ratio = simulatedUnits > 0 ? boostedUnits / simulatedUnits : 1;
-        return String(Math.ceil(Number(fast.txFee) * ratio));
-    },
+    getTradeQuote: (input, deps) => getTradeQuote(input, deps),
+    getTradeRate: (input, deps) => getTradeRate(input, deps),
+    getUnsignedEvmTransaction,
+    getEvmTransactionFees,
+    getUnsignedUtxoTransaction,
+    getUtxoTransactionFees,
+    getUnsignedSolanaTransaction,
+    getSolanaTransactionFees,
     getUnsignedTronTransaction: ({ stepIndex, tradeQuote, from, assertGetTronChainAdapter }) => {
         if (!isExecutableTradeQuote(tradeQuote))
             throw new Error('Unable to execute a trade rate quote');
         const step = getExecutableTradeStep(tradeQuote, stepIndex);
         const { accountNumber, chainflipSpecific, sellAsset } = step;
-        if (!chainflipSpecific?.chainflipDepositAddress)
+        if (!chainflipSpecific?.depositAddress)
             throw Error('Missing deposit address');
-        if (!chainflipSpecific?.chainflipSwapId)
-            throw Error('Missing swap id');
         const adapter = assertGetTronChainAdapter(sellAsset.chainId);
         return adapter.buildSendApiTransaction({
-            to: chainflipSpecific.chainflipDepositAddress,
+            to: chainflipSpecific.depositAddress,
             from,
             value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
             accountNumber,
@@ -184,12 +37,12 @@ export const chainflipApi = {
     },
     getTronTransactionFees,
     checkTradeStatus: async ({ config, swap }) => {
-        const chainflipSwapId = swap?.metadata.chainflipSwapId;
-        if (chainflipSwapId == null)
-            throw Error(`chainflipSwapId is required`);
+        if (!swap)
+            throw new Error('Missing swap');
+        const { swapId } = getSwapMetadata(swap.metadata.swapperMetadata, 'chainflip');
         const brokerUrl = config.VITE_CHAINFLIP_API_URL;
         const apiKey = config.VITE_CHAINFLIP_API_KEY;
-        const maybeStatusResponse = await chainflipService.get(`${brokerUrl}/status-by-id?apiKey=${apiKey}&swapId=${chainflipSwapId}`);
+        const maybeStatusResponse = await chainflipService.get(`${brokerUrl}/status-by-id?apiKey=${apiKey}&swapId=${swapId}`);
         if (maybeStatusResponse.isErr()) {
             return {
                 buyTxHash: undefined,
@@ -199,23 +52,27 @@ export const chainflipApi = {
             };
         }
         const { data: statusResponse } = maybeStatusResponse.unwrap();
-        const { status: { swapEgress, swapId }, } = statusResponse;
+        const buyTxHash = statusResponse.status.swapEgress?.transactionReference;
+        const swapperTxId = statusResponse.status.swapId;
+        const swapperTxLink = swapperTxId ? `https://scan.chainflip.io/swaps/${swapperTxId}` : undefined;
         // Assume no outbound Tx is a pending Tx
-        if (!swapEgress?.transactionReference) {
+        if (!buyTxHash) {
             return {
                 buyTxHash: undefined,
                 status: TxStatus.Pending,
+                swapperTxId,
+                swapperTxLink,
                 message: getLatestChainflipStatusMessage(statusResponse),
-                chainflipSwapId: swapId ?? undefined,
             };
         }
         // Assume as soon as we have an outbound Tx, the swap is complete.
         // Chainflip waits for 3 confirmations to assume complete (vs. 1 for us), which is turbo long.
         return {
-            buyTxHash: swapEgress.transactionReference,
+            buyTxHash,
             status: TxStatus.Confirmed,
+            swapperTxId,
+            swapperTxLink,
             message: undefined,
-            chainflipSwapId: swapId ?? undefined,
         };
     },
 };

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

@@ -1,2 +1,4 @@
 export * from './types.js';
 export * from './constants.js';
+export { chainflipApi } from './endpoints.js';
+export { chainflipSwapper } from './ChainflipSwapper.js';

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

@@ -1,2 +1,4 @@
 export * from './types.js';
 export * from './constants.js';
+export { chainflipApi } from './endpoints.js';
+export { chainflipSwapper } from './ChainflipSwapper.js';

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

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

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

@@ -1,139 +1,85 @@
-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 { CHAINFLIP_CHANNEL_DEADLINE_MS } from '../constants.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',
+            deadline: Date.now() + CHAINFLIP_CHANNEL_DEADLINE_MS,
             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 {};