@shapeshiftoss/swapper 17.7.3 → 18.1.0

package/dist/esm/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.js';
+import type { CowSwapTradeQuoteInput, CowSwapTradeRateInput } from '../types.js';
+import type { GetCowSwapStepDataArgs } from './getCowSwapStepData.js';
+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/esm/swappers/CowSwapper/utils/getCowSwapTradeContext.js

@@ -0,0 +1,134 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { OrderKind, PriceQuality } from '@shapeshiftoss/types';
+import { bn } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { createTradeAmountTooSmallErr, getInputOutputRate, makeSwapErrorRight, } from '../../../utils/index.js';
+import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
+import { getAffiliateAppDataFragmentByChainId, getCowNetwork, getFullAppData, } from '../../../utils/cowswap/index.js';
+import { COW_SWAP_NATIVE_ASSET_MARKER_ADDRESS, COW_SWAP_VAULT_RELAYER_ADDRESS, SUPPORTED_CHAIN_IDS, } from '../../../utils/cowswap/constants.js';
+import { isNativeEvmAsset } from '../../../utils/helpers.js';
+import { cowService } from '../utils/cowService.js';
+import { assertValidTrade, getNowPlusThirtyMinutesTimestamp, getValuesFromQuoteResponse, } from '../utils/helpers.js';
+export const getCowSwapTradeContext = async ({ input, deps, senderAddress, receiveAddress, }) => {
+    const { sellAsset, buyAsset, chainId, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps, } = input;
+    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
+        getDefaultSlippageDecimalPercentageForSwapper(SwapperName.CowSwap);
+    const assertion = assertValidTrade({
+        buyAsset,
+        sellAsset,
+        supportedChainIds: SUPPORTED_CHAIN_IDS,
+    });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const buyToken = !isNativeEvmAsset(buyAsset.assetId)
+        ? fromAssetId(buyAsset.assetId).assetReference
+        : COW_SWAP_NATIVE_ASSET_MARKER_ADDRESS;
+    const network = getCowNetwork(chainId);
+    if (!network)
+        return Err(makeSwapErrorRight({
+            message: `[getCowSwapTradeContext] - Unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId },
+        }));
+    const affiliateAppDataFragment = getAffiliateAppDataFragmentByChainId({
+        affiliateBps,
+        chainId: sellAsset.chainId,
+    });
+    const { appData, appDataHash } = await getFullAppData(slippageTolerancePercentageDecimal, affiliateAppDataFragment, 'market');
+    // https://api.cow.fi/docs/#/default/post_api_v1_quote
+    const maybeQuoteResponse = await cowService.post(`${deps.config.VITE_COWSWAP_BASE_URL}/${network}/api/v1/quote`, {
+        sellToken: fromAssetId(sellAsset.assetId).assetReference,
+        buyToken,
+        receiver: receiveAddress,
+        validTo: getNowPlusThirtyMinutesTimestamp(),
+        appData,
+        appDataHash,
+        partiallyFillable: false,
+        from: senderAddress,
+        kind: 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: PriceQuality.OPTIMAL,
+    });
+    if (maybeQuoteResponse.isErr()) {
+        const err = maybeQuoteResponse.unwrapErr();
+        const errData = err.cause?.response?.data;
+        if (err.cause?.isAxiosError &&
+            errData?.errorType === 'SellAmountDoesNotCoverFee') {
+            return Err(createTradeAmountTooSmallErr({
+                assetId: sellAsset.assetId,
+                minAmountCryptoBaseUnit: bn((errData?.data).fee_amount ?? '0x0', 16).toFixed(),
+            }));
+        }
+        return Err(err);
+    }
+    const { data: cowswapQuoteResponse } = maybeQuoteResponse.unwrap();
+    const { feeAmount: feeAmountInSellTokenCryptoBaseUnit } = cowswapQuoteResponse.quote;
+    const { buyAmountAfterFeesCryptoBaseUnit, buyAmountBeforeFeesCryptoBaseUnit } = getValuesFromQuoteResponse({
+        buyAsset,
+        sellAsset,
+        response: cowswapQuoteResponse,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+    });
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const id = cowswapQuoteResponse.id?.toString();
+    if (!id) {
+        return Err(makeSwapErrorRight({
+            message: `[getCowSwapTradeContext] - missing quote ID`,
+            code: TradeQuoteError.InvalidResponse,
+        }));
+    }
+    return Ok({
+        tradeCommon: {
+            id,
+            rate,
+            swapperName: SwapperName.CowSwap,
+            affiliateBps,
+            slippageTolerancePercentageDecimal,
+        },
+        stepCommon: {
+            estimatedExecutionTimeMs: undefined,
+            allowanceContract: COW_SWAP_VAULT_RELAYER_ADDRESS,
+            rate,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountBeforeFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            source: SwapperName.CowSwap,
+            buyAsset,
+            sellAsset,
+            affiliateFee: 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,
+        },
+    });
+};

package/dist/esm/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.js';
+import type { SwapErrorRight } from '../../../types.js';
 export type CowSwapQuoteApiInputBase = {
     appData: string;
     appDataHash?: string;

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

@@ -1,8 +1,8 @@
 import { fromAssetId } from '@shapeshiftoss/caip';
 import { BigAmount, bn, bnOrZero, convertBasisPointsToDecimalPercentage, convertPrecision, } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
-import { TradeQuoteError } from '../../../../types.js';
-import { makeSwapErrorRight } from '../../../../utils.js';
+import { TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
 export const getNowPlusThirtyMinutesTimestamp = () => {
     const ts = new Date();
     ts.setMinutes(ts.getMinutes() + 30);

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

@@ -0,0 +1,51 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ETH, FOX_MAINNET } from '../../../utils/test-data/assets.js';
+import { getNowPlusThirtyMinutesTimestamp, getValuesFromQuoteResponse } from './helpers.js';
+describe('getNowPlusThirtyMinutesTimestamp', () => {
+    const mockDay = '2020-12-31';
+    const mockTime = 'T23:59:59.000Z';
+    const mockDate = `${mockDay}${mockTime}`;
+    beforeEach(() => {
+        vi.useFakeTimers().setSystemTime(new Date(mockDate));
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+        vi.useRealTimers();
+    });
+    it('should return the timestamp corresponding to current time + 30 minutes (UTC)', () => {
+        const timestamp = getNowPlusThirtyMinutesTimestamp();
+        expect(timestamp).toEqual(1609460999);
+        expect(new Date(timestamp * 1000).toUTCString()).toEqual('Fri, 01 Jan 2021 00:29:59 GMT');
+    });
+});
+describe('getValuesFromQuoteResponse', () => {
+    const response = {
+        quote: {
+            sellAmount: '9755648144619063874259',
+            buyAmount: '289305614806369753',
+            feeAmount: '184116879335769833472',
+        },
+    };
+    it('should deduct affiliate fees then slippage from the quoted buy amount', () => {
+        const { buyAmountAfterFeesCryptoBaseUnit, buyAmountBeforeFeesCryptoBaseUnit } = getValuesFromQuoteResponse({
+            buyAsset: ETH,
+            sellAsset: FOX_MAINNET,
+            response,
+            affiliateBps: '0',
+            slippageTolerancePercentageDecimal: '0.005',
+        });
+        expect(buyAmountAfterFeesCryptoBaseUnit).toEqual('287859086732337904');
+        expect(buyAmountBeforeFeesCryptoBaseUnit).toEqual('294765636137893963');
+    });
+    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 } = getValuesFromQuoteResponse({
+            buyAsset: ETH,
+            sellAsset: FOX_MAINNET,
+            response,
+            affiliateBps: '100',
+            slippageTolerancePercentageDecimal: '0.005',
+        });
+        expect(buyAmountAfterFeesCryptoBaseUnit).toEqual('284980495865014525');
+    });
+});

package/dist/esm/swappers/DebridgeSwapper/DebridgeSwapper.js

@@ -1,4 +1,4 @@
-import { executeEvmTransaction } from '../../utils.js';
+import { executeEvmTransaction } from '../../utils/index.js';
 export const debridgeSwapper = {
     executeEvmTransaction,
 };

package/dist/esm/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/esm/swappers/DebridgeSwapper/constant.js

@@ -27,4 +27,4 @@ export const chainIdToDebridgeChainId = {
 export const debridgeChainIdToChainId = invert(chainIdToDebridgeChainId);
 export const DEBRIDGE_SUPPORTED_CHAIN_IDS = Object.keys(chainIdToDebridgeChainId);
 export const DEFAULT_DEBRIDGE_TOKEN_ADDRESS = zeroAddress;
-export const DEFAULT_DEBRIDGE_USER_ADDRESS = '0x000000000000000000000000000000000000dead';
+export const DEFAULT_DEBRIDGE_USER_ADDRESS = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045';

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

@@ -1,7 +1,6 @@
-import { evm, isEvmChainId } from '@shapeshiftoss/chain-adapters';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
-import BigNumber from 'bignumber.js';
-import { checkEvmSwapStatus, getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { checkEvmSwapStatus, getSwapMetadata } from '../../utils/index.js';
+import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
 import { getTradeQuote } from './getTradeQuote/getTradeQuote.js';
 import { getTradeRate } from './getTradeRate/getTradeRate.js';
 import { debridgeService } from './utils/debridgeService.js';
@@ -9,96 +8,12 @@ const DEBRIDGE_STATS_API_URL = 'https://stats-api.dln.trade';
 export const debridgeApi = {
     getTradeQuote: (input, deps) => getTradeQuote(input, deps),
     getTradeRate: (input, deps) => getTradeRate(input, deps),
-    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 { 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 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 evm.calcNetworkFeeCryptoBaseUnit({
-                ...average,
-                supportsEIP1559,
-                gasLimit: gasLimitFromApi,
-            });
-        }
-    },
-    getUnsignedEvmTransaction: 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 { 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 evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
-                const result = {
-                    ...fees,
-                    gasLimit: BigNumber(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 = 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,
+    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 } = getSwapMetadata(swap.metadata.swapperMetadata, 'debridge');
         if (isSameChainSwap) {
             return checkEvmSwapStatus({
                 txHash,
@@ -108,26 +23,18 @@ export const debridgeApi = {
                 fetchIsSmartContractAddressQuery,
             });
         }
-        let resolvedTxHash = txHash;
-        if (isEvmChainId(chainId)) {
-            const sourceTxStatus = await checkEvmSwapStatus({
-                txHash,
-                chainId,
-                address,
-                assertGetEvmChainAdapter,
-                fetchIsSmartContractAddressQuery,
-            });
-            if (sourceTxStatus.status !== TxStatus.Confirmed)
-                return sourceTxStatus;
-            resolvedTxHash = sourceTxStatus.buyTxHash ?? txHash;
-        }
+        const sourceTxStatus = await checkEvmSwapStatus({
+            txHash,
+            chainId,
+            address,
+            assertGetEvmChainAdapter,
+            fetchIsSmartContractAddressQuery,
+        });
+        if (sourceTxStatus.status !== TxStatus.Confirmed)
+            return sourceTxStatus;
+        const resolvedTxHash = sourceTxStatus.buyTxHash ?? txHash;
         const maybeOrderIdsResponse = await 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: TxStatus.Pending,
@@ -145,12 +52,6 @@ export const debridgeApi = {
         const orderId = orderIdsResponse.orderIds[0].stringValue;
         const maybeStatusResponse = await 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: TxStatus.Unknown,

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

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

@@ -1,27 +1,37 @@
-import { Err } from '@sniptt/monads';
-import { makeSwapErrorRight } from '../../../utils.js';
-import { getTrade } from '../utils/getTrade.js';
-export const getTradeQuote = (input, deps) => {
-    if (!input.sendAddress) {
-        return Promise.resolve(Err(makeSwapErrorRight({
-            message: 'sendAddress is required',
-        })));
-    }
-    if (!input.receiveAddress) {
-        return Promise.resolve(Err(makeSwapErrorRight({
-            message: 'receiveAddress is required',
-        })));
-    }
-    const args = {
-        buyAsset: input.buyAsset,
-        receiveAddress: input.receiveAddress,
-        sellAmountIncludingProtocolFeesCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-        sellAsset: input.sellAsset,
-        sendAddress: input.sendAddress,
+import { Err, Ok } from '@sniptt/monads';
+import { assertQuoteAddresses } from '../../../utils/index.js';
+import { getDebridgeStepData } from '../utils/getDebridgeStepData.js';
+import { getDebridgeTradeContext } from '../utils/getDebridgeTradeContext.js';
+export const getTradeQuote = async (input, deps) => {
+    const maybeAddresses = assertQuoteAddresses(input);
+    if (maybeAddresses.isErr())
+        return Err(maybeAddresses.unwrapErr());
+    const { sendAddress, receiveAddress } = maybeAddresses.unwrap();
+    const maybeContext = await getDebridgeTradeContext({
+        input,
+        deps,
+        senderAddress: sendAddress,
+        recipientAddress: receiveAddress,
+    });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getDebridgeStepData({ ...stepDataArgs, type: 'quote', input });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { transactionData, networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeQuote = {
+        ...tradeCommon,
         quoteOrRate: 'quote',
-        accountNumber: input.accountNumber,
-        affiliateBps: input.affiliateBps,
-        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber: input.accountNumber,
+                transactionData,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
     };
-    return getTrade({ input: args, deps });
+    return Ok([tradeQuote]);
 };

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

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

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

@@ -1,15 +1,35 @@
-import { getTrade } from '../utils/getTrade.js';
-export const getTradeRate = (input, deps) => {
-    const args = {
+import { Err, Ok } from '@sniptt/monads';
+import { DEFAULT_DEBRIDGE_USER_ADDRESS } from '../constant.js';
+import { getDebridgeStepData } from '../utils/getDebridgeStepData.js';
+import { getDebridgeTradeContext } from '../utils/getDebridgeTradeContext.js';
+export const getTradeRate = async (input, deps) => {
+    const { accountNumber } = input;
+    const senderAddress = input.sendAddress ?? DEFAULT_DEBRIDGE_USER_ADDRESS;
+    const recipientAddress = input.receiveAddress ?? DEFAULT_DEBRIDGE_USER_ADDRESS;
+    const maybeContext = await getDebridgeTradeContext({
+        input,
+        deps,
+        senderAddress,
+        recipientAddress,
+    });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getDebridgeStepData({ ...stepDataArgs, type: 'rate', input });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeRate = {
+        ...tradeCommon,
         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,
+        receiveAddress: recipientAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
     };
-    return getTrade({ input: args, deps });
+    return Ok([tradeRate]);
 };

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

@@ -1 +1,2 @@
 export { debridgeSwapper } from './DebridgeSwapper.js';
+export { debridgeApi } from './endpoints.js';

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

@@ -1 +1,2 @@
 export { debridgeSwapper } from './DebridgeSwapper.js';
+export { debridgeApi } from './endpoints.js';

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

@@ -1,5 +1,5 @@
 import axios from 'axios';
-import { makeSwapperAxiosServiceMonadic } from '../../../utils.js';
+import { makeSwapperAxiosServiceMonadic } from '../../../utils/index.js';
 const axiosConfig = {
     timeout: 30000,
     headers: {

package/dist/esm/swappers/DebridgeSwapper/utils/getDebridgeStepData.d.ts

@@ -0,0 +1,26 @@
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.js';
+import type { DebridgeTx } from './types.js';
+type BaseArgs = {
+    tx: DebridgeTx;
+    gasLimit: string | undefined;
+    spenderAddress: string;
+    fallbackNetworkFeeCryptoBaseUnit: string | undefined;
+};
+export type GetDebridgeStepDataArgs = StepDataArgs<BaseArgs, {
+    from: string;
+}>;
+type DebridgeRateStepData = {
+    networkFeeCryptoBaseUnit: string | undefined;
+};
+type DebridgeQuoteStepData = {
+    transactionData: TxBuildData;
+    networkFeeCryptoBaseUnit: string;
+};
+export declare function getDebridgeStepData(args: Extract<GetDebridgeStepDataArgs, {
+    type: 'rate';
+}>): Promise<Result<DebridgeRateStepData, SwapErrorRight>>;
+export declare function getDebridgeStepData(args: Extract<GetDebridgeStepDataArgs, {
+    type: 'quote';
+}>): Promise<Result<DebridgeQuoteStepData, SwapErrorRight>>;
+export {};

package/dist/esm/swappers/DebridgeSwapper/utils/getDebridgeStepData.js

@@ -0,0 +1,54 @@
+import { fromChainId } from '@shapeshiftoss/caip';
+import { Err, Ok } from '@sniptt/monads';
+import { makeNetworkFeeEstimationFailedErr } from '../../../utils/index.js';
+import { getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
+export async function getDebridgeStepData(args) {
+    const { tx, gasLimit, spenderAddress, fallbackNetworkFeeCryptoBaseUnit, sellAsset, from, type, input, deps, } = args;
+    const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+    const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
+    const transactionData = {
+        type: 'evm',
+        chainId: Number(fromChainId(sellAsset.chainId).chainReference),
+        to: tx.to,
+        data: tx.data,
+        value: tx.value,
+        gasLimit,
+    };
+    const stateOverride = {
+        sellAsset,
+        sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        spenderAddress,
+    };
+    if (type === 'rate') {
+        const networkFeeCryptoBaseUnit = await (async () => {
+            try {
+                return await getEvmNetworkFeeCryptoBaseUnit({
+                    adapter,
+                    transactionData,
+                    from,
+                    supportsEIP1559,
+                    stateOverride,
+                });
+            }
+            catch {
+                return fallbackNetworkFeeCryptoBaseUnit;
+            }
+        })();
+        const stepData = { networkFeeCryptoBaseUnit };
+        return Ok(stepData);
+    }
+    try {
+        const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+            adapter,
+            transactionData,
+            from,
+            supportsEIP1559,
+            stateOverride,
+        });
+        const stepData = { transactionData, networkFeeCryptoBaseUnit };
+        return Ok(stepData);
+    }
+    catch (error) {
+        return Err(makeNetworkFeeEstimationFailedErr('getDebridgeStepData', error));
+    }
+}