@shapeshiftoss/swapper 17.8.0 → 19.0.0

package/dist/cjs/swappers/CowSwapper/utils/getCowSwapStepData.test.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const assets_1 = require("../../../utils/test-data/assets");
+const getCowSwapStepData_1 = require("./getCowSwapStepData");
+const cowswapQuoteResponse = {
+    quote: {
+        sellToken: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+        buyToken: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
+        receiver: '0x90a48d5cf7343b08da12e067680b4c6dbfe551be',
+        sellAmount: '9755648144619063874259',
+        buyAmount: '289305614806369753',
+        validTo: 1712259433,
+        appData: '{"appCode":"shapeshift","metadata":{"orderClass":{"orderClass":"market"},"quote":{"slippageBips":50}},"version":"1.3.0"}',
+        appDataHash: '0x41fffc0127f56060cc551652721d84c336f87649a20c51fcff5b8841dfeabe5b',
+        feeAmount: '184116879335769833472',
+        kind: 'sell',
+        partiallyFillable: false,
+        sellTokenBalance: 'erc20',
+        buyTokenBalance: 'erc20',
+        signingScheme: 'eip712',
+    },
+    from: '0x90a48d5cf7343b08da12e067680b4c6dbfe551be',
+    expiration: '2024-04-04T19:09:12.792412370Z',
+    id: 474006349,
+    verified: false,
+};
+const commonArgs = {
+    deps: {},
+    sellAsset: assets_1.FOX_MAINNET,
+    cowswapQuoteResponse,
+    appDataHash: '0x41fffc0127f56060cc551652721d84c336f87649a20c51fcff5b8841dfeabe5b',
+    // quoted buyAmount less 0.5% slippage, as returned by getValuesFromQuoteResponse
+    buyAmountAfterFeesCryptoBaseUnit: '287859086732337904',
+};
+(0, vitest_1.describe)('getCowSwapStepData', () => {
+    (0, vitest_1.describe)('quote', () => {
+        (0, vitest_1.it)('should return the order to sign', () => {
+            const args = {
+                ...commonArgs,
+                type: 'quote',
+                input: {},
+                from: '0x90a48d5cf7343b08da12e067680b4c6dbfe551be',
+            };
+            const actual = (0, getCowSwapStepData_1.getCowSwapStepData)(args).unwrap();
+            (0, vitest_1.expect)(actual).toEqual({
+                networkFeeCryptoBaseUnit: '0',
+                transactionData: {
+                    type: 'cowswap',
+                    chainId: 'eip155:1',
+                    orderToSign: {
+                        sellToken: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+                        buyToken: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
+                        receiver: '0x90a48d5cf7343b08da12e067680b4c6dbfe551be',
+                        sellAmount: '9939765023954833707731',
+                        buyAmount: '287859086732337904',
+                        validTo: 1712259433,
+                        appData: '{"appCode":"shapeshift","metadata":{"orderClass":{"orderClass":"market"},"quote":{"slippageBips":50}},"version":"1.3.0"}',
+                        appDataHash: '0x41fffc0127f56060cc551652721d84c336f87649a20c51fcff5b8841dfeabe5b',
+                        feeAmount: '0',
+                        kind: 'sell',
+                        partiallyFillable: false,
+                        sellTokenBalance: 'erc20',
+                        buyTokenBalance: 'erc20',
+                        signingScheme: 'eip712',
+                        quoteId: 474006349,
+                    },
+                },
+            });
+        });
+    });
+    (0, vitest_1.describe)('rate', () => {
+        (0, vitest_1.it)('should return a zero network fee and no transaction data', () => {
+            const args = {
+                ...commonArgs,
+                type: 'rate',
+                input: {},
+            };
+            const actual = (0, getCowSwapStepData_1.getCowSwapStepData)(args).unwrap();
+            (0, vitest_1.expect)(actual).toEqual({ networkFeeCryptoBaseUnit: '0' });
+        });
+    });
+});

package/dist/cjs/swappers/CowSwapper/utils/getCowSwapTradeContext.d.ts

@@ -0,0 +1,17 @@
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types';
+import type { CowSwapTradeQuoteInput, CowSwapTradeRateInput } from '../types';
+import type { GetCowSwapStepDataArgs } from './getCowSwapStepData';
+type CowSwapTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    stepDataArgs: Omit<GetCowSwapStepDataArgs, 'type' | 'input' | 'from'>;
+};
+export declare const getCowSwapTradeContext: ({ input, deps, senderAddress, receiveAddress, }: {
+    input: CowSwapTradeQuoteInput | CowSwapTradeRateInput;
+    deps: SwapperDeps;
+    senderAddress: string;
+    receiveAddress: string | undefined;
+}) => Promise<Result<CowSwapTradeContext, SwapErrorRight>>;
+export {};

package/dist/cjs/swappers/CowSwapper/utils/getCowSwapTradeContext.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCowSwapTradeContext = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const types_1 = require("@shapeshiftoss/types");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const constants_1 = require("../../../constants");
+const types_2 = require("../../../types");
+const utils_2 = require("../../../utils");
+const affiliateFee_1 = require("../../../utils/affiliateFee");
+const cowswap_1 = require("../../../utils/cowswap");
+const constants_2 = require("../../../utils/cowswap/constants");
+const helpers_1 = require("../../../utils/helpers");
+const cowService_1 = require("../utils/cowService");
+const helpers_2 = require("../utils/helpers");
+const getCowSwapTradeContext = async ({ input, deps, senderAddress, receiveAddress, }) => {
+    const { sellAsset, buyAsset, chainId, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps, } = input;
+    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
+        (0, constants_1.getDefaultSlippageDecimalPercentageForSwapper)(types_2.SwapperName.CowSwap);
+    const assertion = (0, helpers_2.assertValidTrade)({
+        buyAsset,
+        sellAsset,
+        supportedChainIds: constants_2.SUPPORTED_CHAIN_IDS,
+    });
+    if (assertion.isErr())
+        return (0, monads_1.Err)(assertion.unwrapErr());
+    const buyToken = !(0, helpers_1.isNativeEvmAsset)(buyAsset.assetId)
+        ? (0, caip_1.fromAssetId)(buyAsset.assetId).assetReference
+        : constants_2.COW_SWAP_NATIVE_ASSET_MARKER_ADDRESS;
+    const network = (0, cowswap_1.getCowNetwork)(chainId);
+    if (!network)
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `[getCowSwapTradeContext] - Unsupported chainId`,
+            code: types_2.TradeQuoteError.UnsupportedChain,
+            details: { chainId },
+        }));
+    const affiliateAppDataFragment = (0, cowswap_1.getAffiliateAppDataFragmentByChainId)({
+        affiliateBps,
+        chainId: sellAsset.chainId,
+    });
+    const { appData, appDataHash } = await (0, cowswap_1.getFullAppData)(slippageTolerancePercentageDecimal, affiliateAppDataFragment, 'market');
+    // https://api.cow.fi/docs/#/default/post_api_v1_quote
+    const maybeQuoteResponse = await cowService_1.cowService.post(`${deps.config.VITE_COWSWAP_BASE_URL}/${network}/api/v1/quote`, {
+        sellToken: (0, caip_1.fromAssetId)(sellAsset.assetId).assetReference,
+        buyToken,
+        receiver: receiveAddress,
+        validTo: (0, helpers_2.getNowPlusThirtyMinutesTimestamp)(),
+        appData,
+        appDataHash,
+        partiallyFillable: false,
+        from: senderAddress,
+        kind: types_1.OrderKind.SELL,
+        sellAmountBeforeFee: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        // Pinned so rates and quotes resolve against the same estimator set - left unset, CoW picks
+        // per-request and the fee swings enough to trip the rate-to-quote drop warning
+        priceQuality: types_1.PriceQuality.OPTIMAL,
+    });
+    if (maybeQuoteResponse.isErr()) {
+        const err = maybeQuoteResponse.unwrapErr();
+        const errData = err.cause?.response?.data;
+        if (err.cause?.isAxiosError &&
+            errData?.errorType === 'SellAmountDoesNotCoverFee') {
+            return (0, monads_1.Err)((0, utils_2.createTradeAmountTooSmallErr)({
+                assetId: sellAsset.assetId,
+                minAmountCryptoBaseUnit: (0, utils_1.bn)((errData?.data).fee_amount ?? '0x0', 16).toFixed(),
+            }));
+        }
+        return (0, monads_1.Err)(err);
+    }
+    const { data: cowswapQuoteResponse } = maybeQuoteResponse.unwrap();
+    const { feeAmount: feeAmountInSellTokenCryptoBaseUnit } = cowswapQuoteResponse.quote;
+    const { buyAmountAfterFeesCryptoBaseUnit, buyAmountBeforeFeesCryptoBaseUnit } = (0, helpers_2.getValuesFromQuoteResponse)({
+        buyAsset,
+        sellAsset,
+        response: cowswapQuoteResponse,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+    });
+    const rate = (0, utils_2.getInputOutputRate)({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const id = cowswapQuoteResponse.id?.toString();
+    if (!id) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `[getCowSwapTradeContext] - missing quote ID`,
+            code: types_2.TradeQuoteError.InvalidResponse,
+        }));
+    }
+    return (0, monads_1.Ok)({
+        tradeCommon: {
+            id,
+            rate,
+            swapperName: types_2.SwapperName.CowSwap,
+            affiliateBps,
+            slippageTolerancePercentageDecimal,
+        },
+        stepCommon: {
+            estimatedExecutionTimeMs: undefined,
+            allowanceContract: constants_2.COW_SWAP_VAULT_RELAYER_ADDRESS,
+            rate,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountBeforeFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            source: types_2.SwapperName.CowSwap,
+            buyAsset,
+            sellAsset,
+            affiliateFee: (0, affiliateFee_1.buildAffiliateFee)({
+                strategy: 'buy_asset',
+                affiliateBps,
+                sellAsset,
+                buyAsset,
+                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                isEstimate: true,
+            }),
+        },
+        protocolFees: {
+            [sellAsset.assetId]: {
+                amountCryptoBaseUnit: feeAmountInSellTokenCryptoBaseUnit,
+                // Technically requires balance, but we deduct it off the sell amount
+                requiresBalance: false,
+                asset: sellAsset,
+            },
+        },
+        stepDataArgs: {
+            deps,
+            sellAsset,
+            cowswapQuoteResponse,
+            appDataHash,
+            buyAmountAfterFeesCryptoBaseUnit,
+        },
+    });
+};
+exports.getCowSwapTradeContext = getCowSwapTradeContext;

package/dist/cjs/swappers/CowSwapper/utils/{helpers/helpers.d.ts → helpers.d.ts}

@@ -1,7 +1,7 @@
 import type { ChainId } from '@shapeshiftoss/caip';
 import type { Asset, OrderQuoteResponse } from '@shapeshiftoss/types';
 import type { Result } from '@sniptt/monads';
-import type { SwapErrorRight } from '../../../../types';
+import type { SwapErrorRight } from '../../../types';
 export type CowSwapQuoteApiInputBase = {
     appData: string;
     appDataHash?: string;

package/dist/cjs/swappers/CowSwapper/utils/{helpers/helpers.js → helpers.js}

@@ -4,8 +4,8 @@ exports.getValuesFromQuoteResponse = exports.deductSlippageFromAmount = exports.
 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 types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
 const getNowPlusThirtyMinutesTimestamp = () => {
     const ts = new Date();
     ts.setMinutes(ts.getMinutes() + 30);

package/dist/cjs/swappers/CowSwapper/utils/helpers.test.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const assets_1 = require("../../../utils/test-data/assets");
+const helpers_1 = require("./helpers");
+(0, vitest_1.describe)('getNowPlusThirtyMinutesTimestamp', () => {
+    const mockDay = '2020-12-31';
+    const mockTime = 'T23:59:59.000Z';
+    const mockDate = `${mockDay}${mockTime}`;
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.useFakeTimers().setSystemTime(new Date(mockDate));
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.restoreAllMocks();
+        vitest_1.vi.useRealTimers();
+    });
+    (0, vitest_1.it)('should return the timestamp corresponding to current time + 30 minutes (UTC)', () => {
+        const timestamp = (0, helpers_1.getNowPlusThirtyMinutesTimestamp)();
+        (0, vitest_1.expect)(timestamp).toEqual(1609460999);
+        (0, vitest_1.expect)(new Date(timestamp * 1000).toUTCString()).toEqual('Fri, 01 Jan 2021 00:29:59 GMT');
+    });
+});
+(0, vitest_1.describe)('getValuesFromQuoteResponse', () => {
+    const response = {
+        quote: {
+            sellAmount: '9755648144619063874259',
+            buyAmount: '289305614806369753',
+            feeAmount: '184116879335769833472',
+        },
+    };
+    (0, vitest_1.it)('should deduct affiliate fees then slippage from the quoted buy amount', () => {
+        const { buyAmountAfterFeesCryptoBaseUnit, buyAmountBeforeFeesCryptoBaseUnit } = (0, helpers_1.getValuesFromQuoteResponse)({
+            buyAsset: assets_1.ETH,
+            sellAsset: assets_1.FOX_MAINNET,
+            response,
+            affiliateBps: '0',
+            slippageTolerancePercentageDecimal: '0.005',
+        });
+        (0, vitest_1.expect)(buyAmountAfterFeesCryptoBaseUnit).toEqual('287859086732337904');
+        (0, vitest_1.expect)(buyAmountBeforeFeesCryptoBaseUnit).toEqual('294765636137893963');
+    });
+    (0, vitest_1.it)('should deduct affiliate fees before slippage', () => {
+        // 100 bps = 1% affiliate fee off the quoted amount, then 0.5% slippage off the remainder
+        const { buyAmountAfterFeesCryptoBaseUnit } = (0, helpers_1.getValuesFromQuoteResponse)({
+            buyAsset: assets_1.ETH,
+            sellAsset: assets_1.FOX_MAINNET,
+            response,
+            affiliateBps: '100',
+            slippageTolerancePercentageDecimal: '0.005',
+        });
+        (0, vitest_1.expect)(buyAmountAfterFeesCryptoBaseUnit).toEqual('284980495865014525');
+    });
+});

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

@@ -2,4 +2,4 @@ export declare const chainIdToDebridgeChainId: Record<string, number>;
 export declare const debridgeChainIdToChainId: import("lodash").Dictionary<string>;
 export declare const DEBRIDGE_SUPPORTED_CHAIN_IDS: string[];
 export declare const DEFAULT_DEBRIDGE_TOKEN_ADDRESS: "0x0000000000000000000000000000000000000000";
-export declare const DEFAULT_DEBRIDGE_USER_ADDRESS = "0x000000000000000000000000000000000000dead";
+export declare const DEFAULT_DEBRIDGE_USER_ADDRESS = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045";

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

@@ -7,30 +7,32 @@ exports.DEFAULT_DEBRIDGE_USER_ADDRESS = exports.DEFAULT_DEBRIDGE_TOKEN_ADDRESS =
 const caip_1 = require("@shapeshiftoss/caip");
 const invert_1 = __importDefault(require("lodash/invert"));
 const viem_1 = require("viem");
+const chains_1 = require("viem/chains");
 exports.chainIdToDebridgeChainId = {
-    [caip_1.ethChainId]: 1,
-    [caip_1.optimismChainId]: 10,
-    [caip_1.bscChainId]: 56,
+    [caip_1.ethChainId]: chains_1.mainnet.id,
+    [caip_1.optimismChainId]: chains_1.optimism.id,
+    [caip_1.bscChainId]: chains_1.bsc.id,
     [caip_1.gnosisChainId]: 100000002,
-    [caip_1.polygonChainId]: 137,
+    [caip_1.polygonChainId]: chains_1.polygon.id,
     [caip_1.monadChainId]: 100000030,
     [caip_1.hyperEvmChainId]: 100000022,
     [caip_1.seiChainId]: 100000027,
-    [caip_1.baseChainId]: 8453,
+    [caip_1.baseChainId]: chains_1.base.id,
     [caip_1.plasmaChainId]: 100000028,
-    [caip_1.arbitrumChainId]: 42161,
-    [caip_1.avalancheChainId]: 43114,
+    [caip_1.arbitrumChainId]: chains_1.arbitrum.id,
+    [caip_1.avalancheChainId]: chains_1.avalanche.id,
     [caip_1.mantleChainId]: 100000023,
     [caip_1.cronosChainId]: 100000019,
     [caip_1.berachainChainId]: 100000020,
-    [caip_1.lineaChainId]: 59144,
+    [caip_1.lineaChainId]: chains_1.linea.id,
     [caip_1.bobChainId]: 100000021,
     [caip_1.sonicChainId]: 100000014,
     [caip_1.storyChainId]: 100000013,
     [caip_1.flowEvmChainId]: 100000009,
     [caip_1.megaethChainId]: 100000031,
+    [caip_1.robinhoodChainId]: chains_1.robinhood.id,
 };
 exports.debridgeChainIdToChainId = (0, invert_1.default)(exports.chainIdToDebridgeChainId);
 exports.DEBRIDGE_SUPPORTED_CHAIN_IDS = Object.keys(exports.chainIdToDebridgeChainId);
 exports.DEFAULT_DEBRIDGE_TOKEN_ADDRESS = viem_1.zeroAddress;
-exports.DEFAULT_DEBRIDGE_USER_ADDRESS = '0x000000000000000000000000000000000000dead';
+exports.DEFAULT_DEBRIDGE_USER_ADDRESS = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045';

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

@@ -1,13 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.debridgeApi = void 0;
-const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
 const unchained_client_1 = require("@shapeshiftoss/unchained-client");
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
 const utils_1 = require("../../utils");
+const evm_1 = require("../../utils/evm");
 const getTradeQuote_1 = require("./getTradeQuote/getTradeQuote");
 const getTradeRate_1 = require("./getTradeRate/getTradeRate");
 const debridgeService_1 = require("./utils/debridgeService");
@@ -15,96 +11,12 @@ const DEBRIDGE_STATS_API_URL = 'https://stats-api.dln.trade';
 exports.debridgeApi = {
     getTradeQuote: (input, deps) => (0, getTradeQuote_1.getTradeQuote)(input, deps),
     getTradeRate: (input, deps) => (0, getTradeRate_1.getTradeRate)(input, deps),
-    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
-        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
-        const { debridgeTransactionMetadata, sellAsset } = step;
-        if (!debridgeTransactionMetadata)
-            throw new Error('Missing deBridge transaction metadata');
-        const { to, value, data, gasLimit: gasLimitFromApi } = debridgeTransactionMetadata;
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        try {
-            const feeData = await chain_adapters_1.evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
-            return feeData.networkFeeCryptoBaseUnit;
-        }
-        catch (e) {
-            console.error('[deBridge] getEvmTransactionFees: gas estimation failed, using API fallback', {
-                error: e,
-                chainId: sellAsset.chainId,
-                to,
-                value,
-            });
-            if (!gasLimitFromApi)
-                throw new Error('Gas estimation failed and no API gas limit fallback');
-            const { average } = await adapter.getGasFeeData();
-            return chain_adapters_1.evm.calcNetworkFeeCryptoBaseUnit({
-                ...average,
-                supportsEIP1559,
-                gasLimit: gasLimitFromApi,
-            });
-        }
-    },
-    getUnsignedEvmTransaction: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
-        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
-        const { accountNumber, debridgeTransactionMetadata, sellAsset } = step;
-        if (!debridgeTransactionMetadata)
-            throw new Error('Missing deBridge transaction metadata');
-        const { to, value, data, gasLimit: gasLimitFromApi } = debridgeTransactionMetadata;
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        const feeData = await (async () => {
-            try {
-                const fees = await chain_adapters_1.evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
-                const result = {
-                    ...fees,
-                    gasLimit: (0, bignumber_js_1.default)(fees.gasLimit).times('1.2').toFixed(0),
-                };
-                console.log('[deBridge] getUnsignedEvmTransaction feeData', JSON.stringify({
-                    chainId: sellAsset.chainId,
-                    to,
-                    value,
-                    supportsEIP1559,
-                    feesFromEstimate: fees,
-                    gasLimitWithBuffer: result.gasLimit,
-                }));
-                return result;
-            }
-            catch (e) {
-                console.error('[deBridge] getUnsignedEvmTransaction: gas estimation failed, using API fallback', { error: e, chainId: sellAsset.chainId, to, value });
-                if (!gasLimitFromApi)
-                    throw new Error('Gas estimation failed and no API gas limit fallback');
-                const { average } = await adapter.getGasFeeData();
-                const networkFeeCryptoBaseUnit = chain_adapters_1.evm.calcNetworkFeeCryptoBaseUnit({
-                    ...average,
-                    supportsEIP1559,
-                    gasLimit: gasLimitFromApi,
-                });
-                const { gasPrice, maxFeePerGas, maxPriorityFeePerGas } = average;
-                if (supportsEIP1559 && maxFeePerGas && maxPriorityFeePerGas) {
-                    return {
-                        networkFeeCryptoBaseUnit,
-                        gasLimit: gasLimitFromApi,
-                        maxFeePerGas,
-                        maxPriorityFeePerGas,
-                    };
-                }
-                return { networkFeeCryptoBaseUnit, gasLimit: gasLimitFromApi, gasPrice };
-            }
-        })();
-        const unsignedTx = await adapter.buildCustomApiTx({
-            accountNumber,
-            data,
-            from,
-            to,
-            value,
-            ...feeData,
-        });
-        return unsignedTx;
-    },
+    getEvmTransactionFees: evm_1.getEvmTransactionFees,
+    getUnsignedEvmTransaction: evm_1.getUnsignedEvmTransaction,
     checkTradeStatus: async ({ txHash, chainId, address, swap, config, fetchIsSmartContractAddressQuery, assertGetEvmChainAdapter, }) => {
-        const isSameChainSwap = swap?.metadata.debridgeTransactionMetadata?.isSameChainSwap === true;
+        if (!swap)
+            throw new Error('[deBridge] swap is required for status check');
+        const { isSameChainSwap } = (0, utils_1.getSwapMetadata)(swap.metadata.swapperMetadata, 'debridge');
         if (isSameChainSwap) {
             return (0, utils_1.checkEvmSwapStatus)({
                 txHash,
@@ -114,26 +26,18 @@ exports.debridgeApi = {
                 fetchIsSmartContractAddressQuery,
             });
         }
-        let resolvedTxHash = txHash;
-        if ((0, chain_adapters_1.isEvmChainId)(chainId)) {
-            const sourceTxStatus = await (0, utils_1.checkEvmSwapStatus)({
-                txHash,
-                chainId,
-                address,
-                assertGetEvmChainAdapter,
-                fetchIsSmartContractAddressQuery,
-            });
-            if (sourceTxStatus.status !== unchained_client_1.TxStatus.Confirmed)
-                return sourceTxStatus;
-            resolvedTxHash = sourceTxStatus.buyTxHash ?? txHash;
-        }
+        const sourceTxStatus = await (0, utils_1.checkEvmSwapStatus)({
+            txHash,
+            chainId,
+            address,
+            assertGetEvmChainAdapter,
+            fetchIsSmartContractAddressQuery,
+        });
+        if (sourceTxStatus.status !== unchained_client_1.TxStatus.Confirmed)
+            return sourceTxStatus;
+        const resolvedTxHash = sourceTxStatus.buyTxHash ?? txHash;
         const maybeOrderIdsResponse = await debridgeService_1.debridgeService.get(`${DEBRIDGE_STATS_API_URL}/api/Transaction/${resolvedTxHash}/orderIds`);
         if (maybeOrderIdsResponse.isErr()) {
-            console.error('[deBridge] checkTradeStatus: failed to fetch orderIds', {
-                error: maybeOrderIdsResponse.unwrapErr(),
-                txHash: resolvedTxHash,
-                chainId,
-            });
             return {
                 buyTxHash: undefined,
                 status: unchained_client_1.TxStatus.Pending,
@@ -151,12 +55,6 @@ exports.debridgeApi = {
         const orderId = orderIdsResponse.orderIds[0].stringValue;
         const maybeStatusResponse = await debridgeService_1.debridgeService.get(`${config.VITE_DEBRIDGE_API_URL}/dln/order/${orderId}/status`);
         if (maybeStatusResponse.isErr()) {
-            console.error('[deBridge] checkTradeStatus: failed to fetch order status', {
-                error: maybeStatusResponse.unwrapErr(),
-                orderId,
-                txHash: resolvedTxHash,
-                chainId,
-            });
             return {
                 buyTxHash: undefined,
                 status: unchained_client_1.TxStatus.Unknown,

package/dist/cjs/swappers/DebridgeSwapper/getTradeQuote/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 { DebridgeTradeQuoteInput } from '../utils/types';
+export declare const getTradeQuote: (input: DebridgeTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;

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

@@ -3,29 +3,41 @@ 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,
+const helpers_1 = require("../../../utils/helpers");
+const getDebridgeStepData_1 = require("../utils/getDebridgeStepData");
+const getDebridgeTradeContext_1 = require("../utils/getDebridgeTradeContext");
+const getTradeQuote = async (input, deps) => {
+    const maybeAddresses = (0, utils_1.assertQuoteAddresses)(input);
+    if (maybeAddresses.isErr())
+        return (0, monads_1.Err)(maybeAddresses.unwrapErr());
+    const { sendAddress, receiveAddress } = maybeAddresses.unwrap();
+    const maybeContext = await (0, getDebridgeTradeContext_1.getDebridgeTradeContext)({
+        input,
+        deps,
+        senderAddress: sendAddress,
+        recipientAddress: receiveAddress,
+    });
+    if (maybeContext.isErr())
+        return (0, monads_1.Err)(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await (0, getDebridgeStepData_1.getDebridgeStepData)({ ...stepDataArgs, type: 'quote', input });
+    if (maybeStepData.isErr())
+        return (0, monads_1.Err)(maybeStepData.unwrapErr());
+    const { transactionData, networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeQuote = {
+        ...tradeCommon,
         quoteOrRate: 'quote',
-        accountNumber: input.accountNumber,
-        affiliateBps: input.affiliateBps,
-        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+        deadline: Date.now() + helpers_1.FALLBACK_QUOTE_DEADLINE_MS,
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber: input.accountNumber,
+                transactionData,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
     };
-    return (0, getTrade_1.getTrade)({ input: args, deps });
+    return (0, monads_1.Ok)([tradeQuote]);
 };
 exports.getTradeQuote = getTradeQuote;

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

@@ -1,3 +1,4 @@
 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>>;
+import type { SwapErrorRight, SwapperDeps, TradeRate } from '../../../types';
+import type { DebridgeTradeRateInput } from '../utils/types';
+export declare const getTradeRate: (input: DebridgeTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;