@shapeshiftoss/swapper 17.6.10 → 17.7.0

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

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DEBRIDGE_USER_ADDRESS = exports.DEFAULT_DEBRIDGE_TOKEN_ADDRESS = exports.DEBRIDGE_SUPPORTED_CHAIN_IDS = exports.debridgeChainIdToChainId = exports.chainIdToDebridgeChainId = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const invert_1 = __importDefault(require("lodash/invert"));
+const viem_1 = require("viem");
+exports.chainIdToDebridgeChainId = {
+    [caip_1.ethChainId]: 1,
+    [caip_1.optimismChainId]: 10,
+    [caip_1.bscChainId]: 56,
+    [caip_1.gnosisChainId]: 100000002,
+    [caip_1.polygonChainId]: 137,
+    [caip_1.monadChainId]: 100000030,
+    [caip_1.hyperEvmChainId]: 100000022,
+    [caip_1.seiChainId]: 100000027,
+    [caip_1.baseChainId]: 8453,
+    [caip_1.plasmaChainId]: 100000028,
+    [caip_1.arbitrumChainId]: 42161,
+    [caip_1.avalancheChainId]: 43114,
+    [caip_1.mantleChainId]: 100000023,
+    [caip_1.cronosChainId]: 100000019,
+    [caip_1.berachainChainId]: 100000020,
+    [caip_1.lineaChainId]: 59144,
+    [caip_1.bobChainId]: 100000021,
+    [caip_1.sonicChainId]: 100000014,
+    [caip_1.storyChainId]: 100000013,
+    [caip_1.flowEvmChainId]: 100000009,
+    [caip_1.megaethChainId]: 100000031,
+};
+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';

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

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

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

@@ -0,0 +1,217 @@
+"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 getTradeQuote_1 = require("./getTradeQuote/getTradeQuote");
+const getTradeRate_1 = require("./getTradeRate/getTradeRate");
+const debridgeService_1 = require("./utils/debridgeService");
+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;
+    },
+    checkTradeStatus: async ({ txHash, chainId, address, swap, config, fetchIsSmartContractAddressQuery, assertGetEvmChainAdapter, }) => {
+        const isSameChainSwap = swap?.metadata.debridgeTransactionMetadata?.isSameChainSwap === true;
+        if (isSameChainSwap) {
+            return (0, utils_1.checkEvmSwapStatus)({
+                txHash,
+                chainId,
+                address,
+                assertGetEvmChainAdapter,
+                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 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,
+                message: 'Waiting for order confirmation...',
+            };
+        }
+        const { data: orderIdsResponse } = maybeOrderIdsResponse.unwrap();
+        if (!orderIdsResponse.orderIds?.length) {
+            return {
+                buyTxHash: undefined,
+                status: unchained_client_1.TxStatus.Pending,
+                message: 'Waiting for order confirmation...',
+            };
+        }
+        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,
+                message: undefined,
+            };
+        }
+        const { data: statusResponse } = maybeStatusResponse.unwrap();
+        const status = (() => {
+            switch (statusResponse.status) {
+                case 'Fulfilled':
+                case 'SentUnlock':
+                case 'ClaimedUnlock':
+                    return unchained_client_1.TxStatus.Confirmed;
+                case 'Created':
+                case 'None':
+                    return unchained_client_1.TxStatus.Pending;
+                case 'OrderCancelled':
+                case 'SentOrderCancel':
+                case 'ClaimedOrderCancel':
+                    return unchained_client_1.TxStatus.Failed;
+                default:
+                    return unchained_client_1.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 !== unchained_client_1.TxStatus.Confirmed)
+                return undefined;
+            const maybeOrderDetail = await debridgeService_1.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/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.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/{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("../../..").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' | 'false';
+    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>>;