@shapeshiftoss/swapper 17.6.9 → 17.6.11

package/dist/cjs/swappers/DebridgeSwapper/getTradeQuote/getTradeQuote.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeQuote = void 0;
+const monads_1 = require("@sniptt/monads");
+const utils_1 = require("../../../utils");
+const getTrade_1 = require("../utils/getTrade");
+const getTradeQuote = (input, deps) => {
+    if (!input.sendAddress) {
+        return Promise.resolve((0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: 'sendAddress is required',
+        })));
+    }
+    if (!input.receiveAddress) {
+        return Promise.resolve((0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: 'receiveAddress is required',
+        })));
+    }
+    const args = {
+        buyAsset: input.buyAsset,
+        receiveAddress: input.receiveAddress,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        sellAsset: input.sellAsset,
+        sendAddress: input.sendAddress,
+        quoteOrRate: 'quote',
+        accountNumber: input.accountNumber,
+        affiliateBps: input.affiliateBps,
+        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+    };
+    return (0, getTrade_1.getTrade)({ input: args, deps });
+};
+exports.getTradeQuote = getTradeQuote;

package/dist/cjs/swappers/DebridgeSwapper/getTradeRate/getTradeRate.d.ts

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

package/dist/cjs/swappers/DebridgeSwapper/getTradeRate/getTradeRate.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeRate = void 0;
+const getTrade_1 = require("../utils/getTrade");
+const getTradeRate = (input, deps) => {
+    const args = {
+        quoteOrRate: 'rate',
+        buyAsset: input.buyAsset,
+        receiveAddress: input.receiveAddress,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        sellAsset: input.sellAsset,
+        sendAddress: input.sendAddress,
+        accountNumber: input.accountNumber,
+        affiliateBps: input.affiliateBps,
+        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+    };
+    return (0, getTrade_1.getTrade)({ input: args, deps });
+};
+exports.getTradeRate = getTradeRate;

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

@@ -0,0 +1 @@
+export { debridgeSwapper } from './DebridgeSwapper';

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debridgeSwapper = void 0;
+var DebridgeSwapper_1 = require("./DebridgeSwapper");
+Object.defineProperty(exports, "debridgeSwapper", { enumerable: true, get: function () { return DebridgeSwapper_1.debridgeSwapper; } });

package/dist/cjs/swappers/DebridgeSwapper/utils/debridgeService.d.ts

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

package/dist/cjs/swappers/DebridgeSwapper/utils/debridgeService.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debridgeService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("../../../utils");
+const axiosConfig = {
+    timeout: 30000,
+    headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+    },
+};
+const debridgeServiceBase = axios_1.default.create(axiosConfig);
+exports.debridgeService = (0, utils_1.makeSwapperAxiosServiceMonadic)(debridgeServiceBase);

package/dist/cjs/swappers/DebridgeSwapper/utils/fetchDebridgeSingleChainTrade.d.ts

@@ -0,0 +1,16 @@
+import type { Result } from '@sniptt/monads';
+import type { AxiosResponse } from 'axios';
+import type { SwapErrorRight, SwapperConfig } from '../../../types';
+import type { DebridgeSingleChainTransactionResponse } from './types';
+export type DebridgeSingleChainFetchParams = {
+    chainId: number;
+    tokenIn: string;
+    tokenInAmount: string;
+    tokenOut: string;
+    tokenOutRecipient?: string;
+    senderAddress?: string;
+    slippage?: string;
+    affiliateFeePercent?: string;
+    affiliateFeeRecipient?: string;
+};
+export declare const fetchDebridgeSingleChainTrade: (params: DebridgeSingleChainFetchParams, config: SwapperConfig) => Promise<Result<AxiosResponse<DebridgeSingleChainTransactionResponse>, SwapErrorRight>>;

package/dist/cjs/swappers/DebridgeSwapper/utils/fetchDebridgeSingleChainTrade.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchDebridgeSingleChainTrade = void 0;
+const debridgeService_1 = require("./debridgeService");
+const fetchDebridgeSingleChainTrade = (params, config) => {
+    const searchParams = new URLSearchParams();
+    searchParams.set('chainId', params.chainId.toString());
+    searchParams.set('tokenIn', params.tokenIn);
+    searchParams.set('tokenInAmount', params.tokenInAmount);
+    searchParams.set('tokenOut', params.tokenOut);
+    searchParams.set('slippage', params.slippage ?? 'auto');
+    if (params.tokenOutRecipient)
+        searchParams.set('tokenOutRecipient', params.tokenOutRecipient);
+    if (params.senderAddress)
+        searchParams.set('senderAddress', params.senderAddress);
+    if (params.affiliateFeePercent && params.affiliateFeeRecipient) {
+        searchParams.set('affiliateFeePercent', params.affiliateFeePercent);
+        searchParams.set('affiliateFeeRecipient', params.affiliateFeeRecipient);
+    }
+    const url = `${config.VITE_DEBRIDGE_API_URL}/chain/transaction?${searchParams.toString()}`;
+    return debridgeService_1.debridgeService.get(url);
+};
+exports.fetchDebridgeSingleChainTrade = fetchDebridgeSingleChainTrade;

package/dist/cjs/swappers/DebridgeSwapper/utils/fetchDebridgeTrade.d.ts

@@ -0,0 +1,20 @@
+import type { Result } from '@sniptt/monads';
+import type { AxiosResponse } from 'axios';
+import type { SwapErrorRight, SwapperConfig } from '../../../types';
+import type { DebridgeCreateTxResponse } from './types';
+export type DebridgeFetchQuoteParams = {
+    srcChainId: number;
+    srcChainTokenIn: string;
+    srcChainTokenInAmount: string;
+    dstChainId: number;
+    dstChainTokenOut: string;
+    dstChainTokenOutAmount: 'auto';
+    dstChainTokenOutRecipient?: string;
+    srcChainOrderAuthorityAddress?: string;
+    dstChainOrderAuthorityAddress?: string;
+    senderAddress?: string;
+    prependOperatingExpenses: 'true';
+    affiliateFeePercent?: string;
+    affiliateFeeRecipient?: string;
+};
+export declare const fetchDebridgeTrade: (params: DebridgeFetchQuoteParams, config: SwapperConfig) => Promise<Result<AxiosResponse<DebridgeCreateTxResponse>, SwapErrorRight>>;

package/dist/cjs/swappers/DebridgeSwapper/utils/fetchDebridgeTrade.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchDebridgeTrade = void 0;
+const debridgeService_1 = require("./debridgeService");
+const fetchDebridgeTrade = (params, config) => {
+    const searchParams = new URLSearchParams();
+    searchParams.set('srcChainId', params.srcChainId.toString());
+    searchParams.set('srcChainTokenIn', params.srcChainTokenIn);
+    searchParams.set('srcChainTokenInAmount', params.srcChainTokenInAmount);
+    searchParams.set('dstChainId', params.dstChainId.toString());
+    searchParams.set('dstChainTokenOut', params.dstChainTokenOut);
+    searchParams.set('dstChainTokenOutAmount', params.dstChainTokenOutAmount);
+    searchParams.set('prependOperatingExpenses', params.prependOperatingExpenses);
+    if (params.dstChainTokenOutRecipient)
+        searchParams.set('dstChainTokenOutRecipient', params.dstChainTokenOutRecipient);
+    if (params.srcChainOrderAuthorityAddress)
+        searchParams.set('srcChainOrderAuthorityAddress', params.srcChainOrderAuthorityAddress);
+    if (params.dstChainOrderAuthorityAddress)
+        searchParams.set('dstChainOrderAuthorityAddress', params.dstChainOrderAuthorityAddress);
+    if (params.senderAddress)
+        searchParams.set('senderAddress', params.senderAddress);
+    if (params.affiliateFeePercent && params.affiliateFeeRecipient) {
+        searchParams.set('affiliateFeePercent', params.affiliateFeePercent);
+        searchParams.set('affiliateFeeRecipient', params.affiliateFeeRecipient);
+    }
+    const url = `${config.VITE_DEBRIDGE_API_URL}/dln/order/create-tx?${searchParams.toString()}`;
+    return debridgeService_1.debridgeService.get(url);
+};
+exports.fetchDebridgeTrade = fetchDebridgeTrade;

package/dist/cjs/swappers/DebridgeSwapper/utils/getTrade.d.ts

@@ -0,0 +1,11 @@
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight, SwapperDeps, TradeQuote, TradeRate } from '../../../types';
+import type { DebridgeTradeInputParams } from './types';
+export declare function getTrade(args: {
+    input: DebridgeTradeInputParams<'quote'>;
+    deps: SwapperDeps;
+}): Promise<Result<TradeQuote[], SwapErrorRight>>;
+export declare function getTrade(args: {
+    input: DebridgeTradeInputParams<'rate'>;
+    deps: SwapperDeps;
+}): Promise<Result<TradeRate[], SwapErrorRight>>;

package/dist/cjs/swappers/DebridgeSwapper/utils/getTrade.js

@@ -0,0 +1,369 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTrade = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const axios_1 = __importDefault(require("axios"));
+const uuid_1 = require("uuid");
+const viem_1 = require("viem");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const helpers_1 = require("../../utils/helpers/helpers");
+const constant_1 = require("../constant");
+const fetchDebridgeSingleChainTrade_1 = require("./fetchDebridgeSingleChainTrade");
+const fetchDebridgeTrade_1 = require("./fetchDebridgeTrade");
+const types_2 = require("./types");
+const getDebridgeAssetAddress = (assetId) => {
+    if ((0, helpers_1.isNativeEvmAsset)(assetId))
+        return constant_1.DEFAULT_DEBRIDGE_TOKEN_ADDRESS;
+    const { assetReference } = (0, caip_1.fromAssetId)(assetId);
+    return (0, caip_1.isAssetReference)(assetReference) ? viem_1.zeroAddress : assetReference;
+};
+async function getTrade({ input, deps, }) {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const isSameChainSwap = sellAsset.chainId === buyAsset.chainId;
+    const sellDebridgeChainId = constant_1.chainIdToDebridgeChainId[sellAsset.chainId];
+    if (sellDebridgeChainId === undefined) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `Sell asset chain '${sellAsset.chainId}' not supported by deBridge`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    if (!isSameChainSwap) {
+        const buyDebridgeChainId = constant_1.chainIdToDebridgeChainId[buyAsset.chainId];
+        if (buyDebridgeChainId === undefined) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: `Buy asset chain '${buyAsset.chainId}' not supported by deBridge`,
+                code: types_1.TradeQuoteError.UnsupportedChain,
+            }));
+        }
+    }
+    const senderAddress = (() => {
+        if (input.quoteOrRate === 'rate') {
+            if (input.sendAddress)
+                return input.sendAddress;
+            return constant_1.DEFAULT_DEBRIDGE_USER_ADDRESS;
+        }
+        return input.sendAddress ?? constant_1.DEFAULT_DEBRIDGE_USER_ADDRESS;
+    })();
+    const recipientAddress = (() => {
+        if (input.quoteOrRate === 'rate') {
+            if (input.receiveAddress)
+                return input.receiveAddress;
+            return constant_1.DEFAULT_DEBRIDGE_USER_ADDRESS;
+        }
+        return input.receiveAddress;
+    })();
+    const affiliateFeePercent = (() => {
+        if (!(0, utils_1.isTreasuryChainId)(buyAsset.chainId))
+            return undefined;
+        const bps = (0, utils_1.bnOrZero)(affiliateBps);
+        if (!bps.isFinite() || bps.lte(0))
+            return undefined;
+        return bps.div(100).toFixed();
+    })();
+    const affiliateFeeRecipient = (() => {
+        if (affiliateFeePercent === undefined)
+            return undefined;
+        try {
+            return (0, helpers_1.getTreasuryAddressFromChainId)(buyAsset.chainId).toLowerCase();
+        }
+        catch (e) {
+            console.error(`[getTrade] Failed to get treasury address for chainId ${buyAsset.chainId}, affiliate fee will not be applied`, e);
+            return undefined;
+        }
+    })();
+    if (isSameChainSwap) {
+        return getSameChainTrade({
+            input,
+            deps,
+            sellDebridgeChainId,
+            senderAddress,
+            recipientAddress,
+            affiliateFeePercent,
+            affiliateFeeRecipient,
+        });
+    }
+    const buyDebridgeChainId = constant_1.chainIdToDebridgeChainId[buyAsset.chainId];
+    if (buyDebridgeChainId === undefined) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `Buy asset chain '${buyAsset.chainId}' not supported by deBridge`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    const maybeQuote = await (0, fetchDebridgeTrade_1.fetchDebridgeTrade)({
+        srcChainId: sellDebridgeChainId,
+        srcChainTokenIn: getDebridgeAssetAddress(sellAsset.assetId),
+        srcChainTokenInAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        dstChainId: buyDebridgeChainId,
+        dstChainTokenOut: getDebridgeAssetAddress(buyAsset.assetId),
+        dstChainTokenOutAmount: 'auto',
+        dstChainTokenOutRecipient: recipientAddress,
+        srcChainOrderAuthorityAddress: senderAddress,
+        dstChainOrderAuthorityAddress: recipientAddress,
+        senderAddress,
+        prependOperatingExpenses: 'true',
+        affiliateFeePercent,
+        affiliateFeeRecipient,
+    }, deps.config);
+    if (maybeQuote.isErr()) {
+        return handleDebridgeError(maybeQuote.unwrapErr());
+    }
+    const { data: quote } = maybeQuote.unwrap();
+    const buyAmountAfterFeesCryptoBaseUnit = quote.estimation.dstChainTokenOut.recommendedAmount;
+    const rate = (0, utils_2.getInputOutputRate)({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const nativePreFee = (0, utils_1.bnOrZero)(quote.fixFee)
+        .plus((0, utils_1.bnOrZero)(quote.prependedOperatingExpenseCost))
+        .toFixed();
+    const buyAmountBeforeFeesCryptoBaseUnit = buyAmountAfterFeesCryptoBaseUnit;
+    const allowanceContract = (0, chain_adapters_1.isEvmChainId)(sellAsset.chainId) ? quote.tx.to : '';
+    const debridgeTransactionMetadata = {
+        to: quote.tx.to,
+        data: quote.tx.data,
+        value: quote.tx.value,
+        orderId: quote.orderId,
+        gasLimit: quote.estimatedTransactionFee?.details.gasLimit,
+    };
+    const networkFeeCryptoBaseUnit = await getNetworkFee({
+        sellAsset,
+        debridgeTransactionMetadata,
+        senderAddress,
+        deps,
+    });
+    const protocolFeeAssetCaipChainId = constant_1.debridgeChainIdToChainId[sellDebridgeChainId.toString()];
+    const protocolFeeAssetIdForFees = (() => {
+        if (!protocolFeeAssetCaipChainId)
+            return undefined;
+        return (0, utils_1.chainIdToFeeAssetId)(protocolFeeAssetCaipChainId);
+    })();
+    const accountNumber = input.accountNumber;
+    const step = {
+        allowanceContract,
+        rate,
+        buyAmountBeforeFeesCryptoBaseUnit,
+        buyAmountAfterFeesCryptoBaseUnit,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAsset,
+        sellAsset,
+        accountNumber,
+        feeData: {
+            networkFeeCryptoBaseUnit,
+            protocolFees: protocolFeeAssetIdForFees && (0, utils_1.bnOrZero)(nativePreFee).gt(0)
+                ? {
+                    [protocolFeeAssetIdForFees]: {
+                        amountCryptoBaseUnit: nativePreFee,
+                        asset: (0, utils_1.getBaseAsset)(sellAsset.chainId),
+                        requiresBalance: true,
+                    },
+                }
+                : {},
+        },
+        source: types_1.SwapperName.Debridge,
+        estimatedExecutionTimeMs: quote.order.approximateFulfillmentDelay * 1000,
+        debridgeTransactionMetadata,
+    };
+    const baseQuoteOrRate = {
+        id: quote.orderId,
+        rate,
+        swapperName: types_1.SwapperName.Debridge,
+        affiliateBps,
+        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+    };
+    if (input.quoteOrRate === 'quote') {
+        if (!input.receiveAddress) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: 'Receive address is required for quote',
+                code: types_1.TradeQuoteError.InternalError,
+            }));
+        }
+        const tradeQuote = {
+            ...baseQuoteOrRate,
+            steps: [step],
+            receiveAddress: input.receiveAddress,
+            quoteOrRate: 'quote',
+        };
+        return (0, monads_1.Ok)([tradeQuote]);
+    }
+    const tradeRate = {
+        ...baseQuoteOrRate,
+        steps: [step],
+        receiveAddress: recipientAddress,
+        quoteOrRate: 'rate',
+    };
+    return (0, monads_1.Ok)([tradeRate]);
+}
+exports.getTrade = getTrade;
+function handleDebridgeError(error) {
+    if (!axios_1.default.isAxiosError(error.cause)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'Unknown error',
+            code: types_1.TradeQuoteError.UnknownError,
+        }));
+    }
+    const debridgeError = error.cause?.response?.data;
+    if (!(0, types_2.isDebridgeError)(debridgeError)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'Unknown error',
+            code: types_1.TradeQuoteError.UnknownError,
+        }));
+    }
+    const errorMessage = debridgeError.errorMessage ?? debridgeError.message ?? 'Unknown error';
+    return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+        message: errorMessage,
+        code: types_1.TradeQuoteError.UnknownError,
+    }));
+}
+async function getNetworkFee({ sellAsset, debridgeTransactionMetadata, senderAddress, deps, }) {
+    if (!(0, chain_adapters_1.isEvmChainId)(sellAsset.chainId))
+        return undefined;
+    const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+    const { average } = await adapter.getGasFeeData();
+    const supportsEIP1559 = 'maxFeePerGas' in average;
+    try {
+        const feeData = await chain_adapters_1.evm.getFees({
+            adapter,
+            data: debridgeTransactionMetadata.data,
+            to: debridgeTransactionMetadata.to,
+            value: debridgeTransactionMetadata.value,
+            from: senderAddress,
+            supportsEIP1559,
+        });
+        return feeData.networkFeeCryptoBaseUnit;
+    }
+    catch {
+        const gasLimitFromApi = debridgeTransactionMetadata.gasLimit;
+        if (!gasLimitFromApi)
+            return undefined;
+        return chain_adapters_1.evm.calcNetworkFeeCryptoBaseUnit({
+            ...average,
+            gasLimit: gasLimitFromApi,
+            supportsEIP1559,
+        });
+    }
+}
+async function getSameChainTrade({ input, deps, sellDebridgeChainId, senderAddress, recipientAddress, affiliateFeePercent, affiliateFeeRecipient, }) {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const slippage = input.slippageTolerancePercentageDecimal
+        ? (0, utils_1.bnOrZero)(input.slippageTolerancePercentageDecimal).times(100).toFixed()
+        : '5';
+    const maybeQuote = await (0, fetchDebridgeSingleChainTrade_1.fetchDebridgeSingleChainTrade)({
+        chainId: sellDebridgeChainId,
+        tokenIn: getDebridgeAssetAddress(sellAsset.assetId),
+        tokenInAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        tokenOut: getDebridgeAssetAddress(buyAsset.assetId),
+        tokenOutRecipient: recipientAddress,
+        senderAddress,
+        slippage,
+        affiliateFeePercent,
+        affiliateFeeRecipient,
+    }, deps.config);
+    if (maybeQuote.isErr()) {
+        return handleDebridgeError(maybeQuote.unwrapErr());
+    }
+    const { data: quote } = maybeQuote.unwrap();
+    const buyAmountAfterFeesCryptoBaseUnit = quote.tokenOut.amount;
+    const rate = (0, utils_2.getInputOutputRate)({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const protocolFeeAmount = quote.protocolFee ?? '0';
+    const buyAmountBeforeFeesCryptoBaseUnit = (() => {
+        if (protocolFeeAmount === '0')
+            return buyAmountAfterFeesCryptoBaseUnit;
+        return utils_1.BigAmount.fromBaseUnit({
+            value: buyAmountAfterFeesCryptoBaseUnit,
+            precision: buyAsset.precision,
+        })
+            .plus(utils_1.BigAmount.fromBaseUnit({
+            value: protocolFeeAmount,
+            precision: buyAsset.precision,
+        }))
+            .toBaseUnit();
+    })();
+    const allowanceContract = (0, chain_adapters_1.isEvmChainId)(sellAsset.chainId) ? quote.tx.to : '';
+    const debridgeTransactionMetadata = {
+        to: quote.tx.to,
+        data: quote.tx.data,
+        value: quote.tx.value,
+        gasLimit: quote.estimatedTransactionFee?.details.gasLimit,
+        isSameChainSwap: true,
+    };
+    const networkFeeCryptoBaseUnit = await getNetworkFee({
+        sellAsset,
+        debridgeTransactionMetadata,
+        senderAddress,
+        deps,
+    });
+    const tradeId = (0, uuid_1.v4)();
+    const step = {
+        allowanceContract,
+        rate,
+        buyAmountBeforeFeesCryptoBaseUnit,
+        buyAmountAfterFeesCryptoBaseUnit,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAsset,
+        sellAsset,
+        accountNumber: input.accountNumber,
+        feeData: {
+            networkFeeCryptoBaseUnit,
+            protocolFees: protocolFeeAmount !== '0'
+                ? {
+                    [buyAsset.assetId]: {
+                        amountCryptoBaseUnit: protocolFeeAmount,
+                        asset: {
+                            symbol: quote.tokenOut.symbol,
+                            chainId: buyAsset.chainId,
+                            precision: buyAsset.precision,
+                        },
+                        requiresBalance: false,
+                    },
+                }
+                : {},
+        },
+        source: types_1.SwapperName.Debridge,
+        estimatedExecutionTimeMs: 15_000,
+        debridgeTransactionMetadata,
+    };
+    const baseQuoteOrRate = {
+        id: tradeId,
+        rate,
+        swapperName: types_1.SwapperName.Debridge,
+        affiliateBps,
+        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal ??
+            (quote.slippage ? (0, utils_1.bnOrZero)(quote.slippage).div(100).toString() : undefined),
+    };
+    if (input.quoteOrRate === 'quote') {
+        if (!input.receiveAddress) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: 'Receive address is required for quote',
+                code: types_1.TradeQuoteError.InternalError,
+            }));
+        }
+        const tradeQuote = {
+            ...baseQuoteOrRate,
+            steps: [step],
+            receiveAddress: input.receiveAddress,
+            quoteOrRate: 'quote',
+        };
+        return (0, monads_1.Ok)([tradeQuote]);
+    }
+    const tradeRate = {
+        ...baseQuoteOrRate,
+        steps: [step],
+        receiveAddress: recipientAddress,
+        quoteOrRate: 'rate',
+    };
+    return (0, monads_1.Ok)([tradeRate]);
+}