@shapeshiftoss/swapper 17.6.10 → 17.7.0

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

@@ -0,0 +1,5 @@
+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";

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

@@ -0,0 +1,30 @@
+import { arbitrumChainId, avalancheChainId, baseChainId, berachainChainId, bobChainId, bscChainId, cronosChainId, ethChainId, flowEvmChainId, gnosisChainId, hyperEvmChainId, lineaChainId, mantleChainId, megaethChainId, monadChainId, optimismChainId, plasmaChainId, polygonChainId, seiChainId, sonicChainId, storyChainId, } from '@shapeshiftoss/caip';
+import invert from 'lodash/invert';
+import { zeroAddress } from 'viem';
+export const chainIdToDebridgeChainId = {
+    [ethChainId]: 1,
+    [optimismChainId]: 10,
+    [bscChainId]: 56,
+    [gnosisChainId]: 100000002,
+    [polygonChainId]: 137,
+    [monadChainId]: 100000030,
+    [hyperEvmChainId]: 100000022,
+    [seiChainId]: 100000027,
+    [baseChainId]: 8453,
+    [plasmaChainId]: 100000028,
+    [arbitrumChainId]: 42161,
+    [avalancheChainId]: 43114,
+    [mantleChainId]: 100000023,
+    [cronosChainId]: 100000019,
+    [berachainChainId]: 100000020,
+    [lineaChainId]: 59144,
+    [bobChainId]: 100000021,
+    [sonicChainId]: 100000014,
+    [storyChainId]: 100000013,
+    [flowEvmChainId]: 100000009,
+    [megaethChainId]: 100000031,
+};
+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';

package/dist/esm/swappers/{JupiterSwapper → DebridgeSwapper}/endpoints.d.ts

@@ -1,2 +1,2 @@
 import type { SwapperApi } from '../../types.js';
-export declare const jupiterApi: SwapperApi;
+export declare const debridgeApi: SwapperApi;

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

@@ -0,0 +1,211 @@
+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 { getTradeQuote } from './getTradeQuote/getTradeQuote.js';
+import { getTradeRate } from './getTradeRate/getTradeRate.js';
+import { debridgeService } from './utils/debridgeService.js';
+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;
+    },
+    checkTradeStatus: async ({ txHash, chainId, address, swap, config, fetchIsSmartContractAddressQuery, assertGetEvmChainAdapter, }) => {
+        const isSameChainSwap = swap?.metadata.debridgeTransactionMetadata?.isSameChainSwap === true;
+        if (isSameChainSwap) {
+            return checkEvmSwapStatus({
+                txHash,
+                chainId,
+                address,
+                assertGetEvmChainAdapter,
+                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 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,
+                message: 'Waiting for order confirmation...',
+            };
+        }
+        const { data: orderIdsResponse } = maybeOrderIdsResponse.unwrap();
+        if (!orderIdsResponse.orderIds?.length) {
+            return {
+                buyTxHash: undefined,
+                status: TxStatus.Pending,
+                message: 'Waiting for order confirmation...',
+            };
+        }
+        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,
+                message: undefined,
+            };
+        }
+        const { data: statusResponse } = maybeStatusResponse.unwrap();
+        const status = (() => {
+            switch (statusResponse.status) {
+                case 'Fulfilled':
+                case 'SentUnlock':
+                case 'ClaimedUnlock':
+                    return TxStatus.Confirmed;
+                case 'Created':
+                case 'None':
+                    return TxStatus.Pending;
+                case 'OrderCancelled':
+                case 'SentOrderCancel':
+                case 'ClaimedOrderCancel':
+                    return TxStatus.Failed;
+                default:
+                    return TxStatus.Unknown;
+            }
+        })();
+        const message = (() => {
+            switch (statusResponse.status) {
+                case 'Created':
+                case 'None':
+                    return 'Order created, waiting for solver fulfillment...';
+                case 'Fulfilled':
+                    return 'Order fulfilled, unlocking funds...';
+                case 'SentUnlock':
+                    return 'Unlock transaction sent...';
+                case 'OrderCancelled':
+                    return 'Order was cancelled';
+                case 'SentOrderCancel':
+                    return 'Cancellation in progress...';
+                case 'ClaimedOrderCancel':
+                    return 'Order cancelled and refunded';
+                default:
+                    return undefined;
+            }
+        })();
+        const buyTxHash = await (async () => {
+            if (status !== TxStatus.Confirmed)
+                return undefined;
+            const maybeOrderDetail = await debridgeService.get(`${DEBRIDGE_STATS_API_URL}/api/Orders/${orderId}`);
+            if (maybeOrderDetail.isErr())
+                return undefined;
+            return maybeOrderDetail.unwrap().data.fulfilledDstEventMetadata?.transactionHash?.stringValue;
+        })();
+        return {
+            status,
+            buyTxHash,
+            message,
+        };
+    },
+};

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

@@ -0,0 +1,27 @@
+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,
+        quoteOrRate: 'quote',
+        accountNumber: input.accountNumber,
+        affiliateBps: input.affiliateBps,
+        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+    };
+    return getTrade({ input: args, deps });
+};

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

@@ -0,0 +1,15 @@
+import { getTrade } from '../utils/getTrade.js';
+export 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 getTrade({ input: args, deps });
+};

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

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

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

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

package/dist/esm/swappers/{JupiterSwapper/utils/jupiterService.d.ts → DebridgeSwapper/utils/debridgeService.d.ts}

@@ -1,4 +1,4 @@
-export declare const jupiterService: {
+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("../../../index.js").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("../../../index.js").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("../../../index.js").SwapErrorRight>>;

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

@@ -0,0 +1,11 @@
+import axios from 'axios';
+import { makeSwapperAxiosServiceMonadic } from '../../../utils.js';
+const axiosConfig = {
+    timeout: 30000,
+    headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+    },
+};
+const debridgeServiceBase = axios.create(axiosConfig);
+export const debridgeService = makeSwapperAxiosServiceMonadic(debridgeServiceBase);

package/dist/esm/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.js';
+import type { DebridgeSingleChainTransactionResponse } from './types.js';
+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/esm/swappers/DebridgeSwapper/utils/fetchDebridgeSingleChainTrade.js

@@ -0,0 +1,19 @@
+import { debridgeService } from './debridgeService.js';
+export 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.get(url);
+};

package/dist/esm/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.js';
+import type { DebridgeCreateTxResponse } from './types.js';
+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' | 'false';
+    affiliateFeePercent?: string;
+    affiliateFeeRecipient?: string;
+};
+export declare const fetchDebridgeTrade: (params: DebridgeFetchQuoteParams, config: SwapperConfig) => Promise<Result<AxiosResponse<DebridgeCreateTxResponse>, SwapErrorRight>>;

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

@@ -0,0 +1,25 @@
+import { debridgeService } from './debridgeService.js';
+export 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.get(url);
+};

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

@@ -0,0 +1,11 @@
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight, SwapperDeps, TradeQuote, TradeRate } from '../../../types.js';
+import type { DebridgeTradeInputParams } from './types.js';
+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>>;