@shapeshiftoss/swapper 17.7.3 → 18.1.0

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

@@ -1,178 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.chainflipApi = void 0;
-const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
 const unchained_client_1 = require("@shapeshiftoss/unchained-client");
 const utils_1 = require("@shapeshiftoss/utils");
 const utils_2 = require("../../utils");
-const helpers_1 = require("../utils/helpers/helpers");
+const evm_1 = require("../../utils/evm");
+const solana_1 = require("../../utils/solana");
+const tron_1 = require("../../utils/tron");
+const utxo_1 = require("../../utils/utxo");
 const constants_1 = require("./constants");
 const getTradeQuote_1 = require("./swapperApi/getTradeQuote");
 const getTradeRate_1 = require("./swapperApi/getTradeRate");
 const chainflipService_1 = require("./utils/chainflipService");
 const getLatestChainflipStatusMessage_1 = require("./utils/getLatestChainflipStatusMessage");
 exports.chainflipApi = {
-    getTradeQuote: getTradeQuote_1.getTradeQuote,
-    getTradeRate: getTradeRate_1.getTradeRate,
-    getUnsignedEvmTransaction: async ({ from, stepIndex, tradeQuote, assertGetEvmChainAdapter, supportsEIP1559, }) => {
+    getTradeQuote: (input, deps) => (0, getTradeQuote_1.getTradeQuote)(input, deps),
+    getTradeRate: (input, deps) => (0, getTradeRate_1.getTradeRate)(input, deps),
+    getUnsignedEvmTransaction: evm_1.getUnsignedEvmTransaction,
+    getEvmTransactionFees: evm_1.getEvmTransactionFees,
+    getUnsignedUtxoTransaction: utxo_1.getUnsignedUtxoTransaction,
+    getUtxoTransactionFees: utxo_1.getUtxoTransactionFees,
+    getUnsignedSolanaTransaction: solana_1.getUnsignedSolanaTransaction,
+    getSolanaTransactionFees: solana_1.getSolanaTransactionFees,
+    getUnsignedTronTransaction: ({ stepIndex, tradeQuote, from, assertGetTronChainAdapter }) => {
         if (!(0, utils_2.isExecutableTradeQuote)(tradeQuote))
             throw new Error('Unable to execute a trade rate quote');
         const step = (0, utils_2.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 = assertGetEvmChainAdapter(sellAsset.chainId);
-        const to = chainflipSpecific.chainflipDepositAddress;
-        const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
-        const contractAddress = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
-        const data = chain_adapters_1.evm.getErc20Data(to, value, contractAddress);
-        const feeData = await chain_adapters_1.evm.getFees({
-            adapter,
-            data: data || '0x',
-            to: contractAddress ?? to,
-            value: (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId) ? value : '0',
-            from,
-            supportsEIP1559,
-        });
+        const adapter = assertGetTronChainAdapter(sellAsset.chainId);
         return adapter.buildSendApiTransaction({
-            accountNumber,
+            to: chainflipSpecific.depositAddress,
             from,
-            to,
-            value,
-            chainSpecific: { contractAddress, ...feeData },
-        });
-    },
-    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
-        if (!(0, utils_2.isExecutableTradeQuote)(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = (0, utils_2.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 = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
-        const to = chainflipSpecific.chainflipDepositAddress;
-        const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
-        const data = chain_adapters_1.evm.getErc20Data(to, value, contractAddress);
-        const { networkFeeCryptoBaseUnit } = await chain_adapters_1.evm.getFees({
-            adapter,
-            data: data || '0x',
-            to: contractAddress ?? to,
-            value: (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId) ? value : '0',
-            from,
-            supportsEIP1559,
-        });
-        return networkFeeCryptoBaseUnit;
-    },
-    getUnsignedUtxoTransaction: ({ stepIndex, tradeQuote, xpub, accountType, assertGetUtxoChainAdapter, }) => {
-        if (!(0, utils_2.isExecutableTradeQuote)(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = (0, utils_2.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 (!(0, utils_2.isExecutableTradeQuote)(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = (0, utils_2.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 (!(0, utils_2.isExecutableTradeQuote)(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = (0, utils_2.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 = (0, utils_1.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 (!(0, utils_2.isExecutableTradeQuote)(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = (0, utils_2.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: (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId),
-            },
+            chainSpecific: { contractAddress: (0, utils_1.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));
     },
+    getTronTransactionFees: tron_1.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 } = (0, utils_2.getSwapMetadata)(swap.metadata.swapperMetadata, 'chainflip');
         const brokerUrl = config.VITE_CHAINFLIP_API_URL;
         const apiKey = config.VITE_CHAINFLIP_API_KEY;
-        const maybeStatusResponse = await chainflipService_1.chainflipService.get(`${brokerUrl}/status-by-id?apiKey=${apiKey}&swapId=${chainflipSwapId}`);
+        const maybeStatusResponse = await chainflipService_1.chainflipService.get(`${brokerUrl}/status-by-id?apiKey=${apiKey}&swapId=${swapId}`);
         if (maybeStatusResponse.isErr()) {
             return {
                 buyTxHash: undefined,
@@ -182,23 +55,27 @@ exports.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: unchained_client_1.TxStatus.Pending,
+                swapperTxId,
+                swapperTxLink,
                 message: (0, getLatestChainflipStatusMessage_1.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: unchained_client_1.TxStatus.Confirmed,
+            swapperTxId,
+            swapperTxLink,
             message: undefined,
-            chainflipSwapId: swapId ?? undefined,
         };
     },
 };

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

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

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

@@ -14,5 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.chainflipSwapper = exports.chainflipApi = void 0;
 __exportStar(require("./types"), exports);
 __exportStar(require("./constants"), exports);
+var endpoints_1 = require("./endpoints");
+Object.defineProperty(exports, "chainflipApi", { enumerable: true, get: function () { return endpoints_1.chainflipApi; } });
+var ChainflipSwapper_1 = require("./ChainflipSwapper");
+Object.defineProperty(exports, "chainflipSwapper", { enumerable: true, get: function () { return ChainflipSwapper_1.chainflipSwapper; } });

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

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

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

@@ -1,143 +1,87 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTradeQuote = void 0;
-const caip_1 = require("@shapeshiftoss/caip");
-const utils_1 = require("@shapeshiftoss/utils");
 const monads_1 = require("@sniptt/monads");
 const types_1 = require("../../../types");
-const utils_2 = require("../../../utils");
-const getQuoteOrRate_1 = require("../utils/getQuoteOrRate");
+const utils_1 = require("../../../utils");
+const getChainflipStepData_1 = require("../utils/getChainflipStepData");
+const getChainflipTradeContexts_1 = require("../utils/getChainflipTradeContexts");
 const helpers_1 = require("../utils/helpers");
 const getTradeQuote = async (input, deps) => {
-    const { sellAsset, buyAsset, accountNumber, sendAddress, receiveAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, } = input;
-    if (accountNumber === undefined) {
-        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
-            message: `accountNumber is required`,
-            code: types_1.TradeQuoteError.UnknownError,
-        }));
-    }
-    if (sendAddress === undefined) {
-        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
-            message: `sendAddress is required`,
-            code: types_1.TradeQuoteError.UnknownError,
-        }));
-    }
-    if (receiveAddress === undefined) {
-        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
-            message: `receiveAddress is required`,
-            code: types_1.TradeQuoteError.UnknownError,
-        }));
-    }
-    const maybeTradeQuotes = await (0, getQuoteOrRate_1.getQuoteOrRate)(input, deps);
-    if (maybeTradeQuotes.isErr())
-        return (0, monads_1.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 (0, helpers_1.getChainFlipIdFromAssetId)({
-                assetId: sellAsset.assetId,
-                brokerUrl,
-            });
-            const maybeDestinationAsset = await (0, helpers_1.getChainFlipIdFromAssetId)({
-                assetId: buyAsset.assetId,
-                brokerUrl,
-            });
-            if (maybeDestinationAsset.isErr())
-                return (0, monads_1.Err)(maybeDestinationAsset.unwrapErr());
-            if (maybeSourceAsset.isErr())
-                return (0, monads_1.Err)(maybeSourceAsset.unwrapErr());
-            const destinationAsset = maybeDestinationAsset.unwrap();
-            const sourceAsset = maybeSourceAsset.unwrap();
-            const minimumPrice = (0, helpers_1.calculateChainflipMinPrice)({
-                slippageTolerancePercentageDecimal: tradeQuote.slippageTolerancePercentageDecimal,
-                sellAsset,
-                buyAsset,
-                buyAmountAfterFeesCryptoBaseUnit: step.buyAmountAfterFeesCryptoBaseUnit,
-                sellAmountIncludingProtocolFeesCryptoBaseUnit: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            });
-            const serviceCommission = parseInt(tradeQuote.affiliateBps);
-            const maybeSwapResponse = await (0, helpers_1.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 (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
-                    message: `Error fetching Chainflip swap`,
-                    code: types_1.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 } = (0, caip_1.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 caip_1.CHAIN_NAMESPACE.Solana: {
-                        const sellAdapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
-                        const getFeeDataInput = {
-                            to: depositAddress,
-                            value: sellAmount,
-                            chainSpecific: {
-                                from: sendAddress,
-                                tokenId: sellAsset.assetId === caip_1.solAssetId
-                                    ? undefined
-                                    : (0, caip_1.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 = (0, utils_1.assertQuoteAddresses)(input);
+    if (maybeAddresses.isErr())
+        return (0, monads_1.Err)(maybeAddresses.unwrapErr());
+    const { sendAddress, receiveAddress } = maybeAddresses.unwrap();
+    const maybeTradeContexts = await (0, getChainflipTradeContexts_1.getChainflipTradeContexts)(input, deps);
+    if (maybeTradeContexts.isErr())
+        return (0, monads_1.Err)(maybeTradeContexts.unwrapErr());
+    const tradeContexts = maybeTradeContexts.unwrap();
+    const tradeQuotes = [];
+    for (const { tradeCommon, stepCommon, protocolFees, stepDataArgs, channelParams, } of tradeContexts) {
+        const minimumPrice = (0, helpers_1.calculateChainflipMinPrice)({
+            slippageTolerancePercentageDecimal: tradeCommon.slippageTolerancePercentageDecimal,
+            sellAsset,
+            buyAsset,
+            buyAmountAfterFeesCryptoBaseUnit: channelParams.buyAmountAfterFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit: stepCommon.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        });
+        const maybeSwapResponse = await (0, helpers_1.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 (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+                message: 'Error fetching Chainflip swap',
+                code: types_1.TradeQuoteError.UnknownError,
+            }));
         }
-    }
-    const quotesResult = (0, monads_1.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 (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+                message: 'Invalid swap response',
+                code: types_1.TradeQuoteError.UnknownError,
+            }));
         }
-        return {
-            ...quote,
+        const maybeStepData = await (0, getChainflipStepData_1.getChainflipStepData)({
+            ...stepDataArgs,
+            type: 'quote',
+            input,
+            depositAddress,
+            from: sendAddress,
+        });
+        if (maybeStepData.isErr())
+            return (0, monads_1.Err)(maybeStepData.unwrapErr());
+        const { transactionData, networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+        tradeQuotes.push({
+            ...tradeCommon,
             quoteOrRate: 'quote',
             receiveAddress,
-            steps: quote.steps.map(step => step),
-        };
-    })
-        .filter(utils_1.isSome));
+            steps: [
+                {
+                    ...stepCommon,
+                    accountNumber,
+                    chainflipSpecific: { depositAddress },
+                    swapperMetadata: { name: 'chainflip', swapId },
+                    transactionData,
+                    feeData: { networkFeeCryptoBaseUnit, protocolFees },
+                },
+            ],
+        });
+    }
+    return (0, monads_1.Ok)(tradeQuotes);
 };
 exports.getTradeQuote = getTradeQuote;

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

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

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

@@ -1,13 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTradeRate = void 0;
-const getQuoteOrRate_1 = require("../utils/getQuoteOrRate");
+const monads_1 = require("@sniptt/monads");
+const getChainflipStepData_1 = require("../utils/getChainflipStepData");
+const getChainflipTradeContexts_1 = require("../utils/getChainflipTradeContexts");
 const getTradeRate = async (input, deps) => {
-    const ratesResult = await (0, getQuoteOrRate_1.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 (0, getChainflipTradeContexts_1.getChainflipTradeContexts)(input, deps);
+    if (maybeTradeContexts.isErr())
+        return (0, monads_1.Err)(maybeTradeContexts.unwrapErr());
+    const tradeContexts = maybeTradeContexts.unwrap();
+    const tradeRates = [];
+    for (const { tradeCommon, stepCommon, protocolFees, stepDataArgs } of tradeContexts) {
+        const maybeStepData = await (0, getChainflipStepData_1.getChainflipStepData)({
+            ...stepDataArgs,
+            type: 'rate',
+            input,
+            from: input.sendAddress,
+        });
+        if (maybeStepData.isErr())
+            return (0, monads_1.Err)(maybeStepData.unwrapErr());
+        const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+        tradeRates.push({
+            ...tradeCommon,
+            quoteOrRate: 'rate',
+            receiveAddress: input.receiveAddress,
+            steps: [
+                {
+                    ...stepCommon,
+                    accountNumber,
+                    feeData: { networkFeeCryptoBaseUnit, protocolFees },
+                },
+            ],
+        });
+    }
+    return (0, monads_1.Ok)(tradeRates);
 };
 exports.getTradeRate = getTradeRate;

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

@@ -1,5 +1,12 @@
+import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput, GetSolanaTradeQuoteInput, GetSolanaTradeRateInput, GetTronTradeQuoteInput, GetTronTradeRateInput, GetUtxoTradeQuoteInput, GetUtxoTradeRateInput } from '../../types';
 import type { ChainflipBaasStatusEgress } from './models/ChainflipBaasStatusEgress';
 import type { ChainflipBaasStatusSwap } from './models/ChainflipBaasStatusSwap';
+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';
@@ -12,5 +19,6 @@ export declare enum ChainflipNetwork {
     Bitcoin = "Bitcoin",
     Ethereum = "Ethereum",
     Arbitrum = "Arbitrum",
-    Solana = "Solana"
+    Solana = "Solana",
+    Tron = "Tron"
 }

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

@@ -7,4 +7,5 @@ var ChainflipNetwork;
     ChainflipNetwork["Ethereum"] = "Ethereum";
     ChainflipNetwork["Arbitrum"] = "Arbitrum";
     ChainflipNetwork["Solana"] = "Solana";
+    ChainflipNetwork["Tron"] = "Tron";
 })(ChainflipNetwork || (exports.ChainflipNetwork = ChainflipNetwork = {}));

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

@@ -0,0 +1,26 @@
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types';
+import type { SolanaComputeBudgetOptions } from '../../../utils/solana';
+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 {};