@shapeshiftoss/swapper 17.6.5 → 17.6.6-alpha.1

package/dist/cjs/swappers/NearIntentsSwapper/swapperApi/getTradeRate.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeRate = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const uuid_1 = require("uuid");
+const viem_1 = require("viem");
+const constants_1 = require("../../../constants");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const tenderly_1 = require("../../../utils/tenderly");
+const helpers_1 = require("../../utils/helpers/helpers");
+const constants_2 = require("../constants");
+const types_2 = require("../types");
+const helpers_2 = require("../utils/helpers/helpers");
+const oneClickService_1 = require("../utils/oneClickService");
+const getTradeRate = async (input, deps) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, slippageTolerancePercentageDecimal, affiliateBps, sendAddress, receiveAddress, } = input;
+    try {
+        (0, oneClickService_1.initializeOneClickService)(deps.config.VITE_NEAR_INTENTS_API_KEY);
+        const originAsset = await (0, helpers_2.assetToNearIntentsAsset)(sellAsset);
+        const destinationAsset = await (0, helpers_2.assetToNearIntentsAsset)(buyAsset);
+        if (!(originAsset && destinationAsset)) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                code: types_1.TradeQuoteError.UnsupportedTradePair,
+                message: 'Unsupported asset',
+            }));
+        }
+        // Wallet connected: use actual addresses
+        // No wallet: use "check-price" sentinel with INTENTS types
+        const hasWallet = sendAddress !== undefined;
+        const quoteRequest = {
+            dry: false,
+            swapType: types_2.QuoteRequest.swapType.EXACT_INPUT,
+            slippageTolerance: slippageTolerancePercentageDecimal
+                ? (0, utils_1.bnOrZero)(slippageTolerancePercentageDecimal).times(10000).toNumber()
+                : constants_2.DEFAULT_SLIPPAGE_BPS,
+            originAsset,
+            destinationAsset,
+            amount: sellAmount,
+            depositType: types_2.QuoteRequest.depositType.ORIGIN_CHAIN,
+            refundTo: sendAddress ?? 'check-price',
+            refundType: hasWallet
+                ? types_2.QuoteRequest.refundType.ORIGIN_CHAIN
+                : types_2.QuoteRequest.refundType.INTENTS,
+            recipient: receiveAddress ?? 'check-price',
+            recipientType: hasWallet
+                ? types_2.QuoteRequest.recipientType.DESTINATION_CHAIN
+                : types_2.QuoteRequest.recipientType.INTENTS,
+            deadline: new Date(Date.now() + constants_2.DEFAULT_QUOTE_DEADLINE_MS).toISOString(),
+            referral: 'shapeshift',
+            appFees: [
+                {
+                    recipient: utils_1.DAO_TREASURY_NEAR,
+                    fee: Number(affiliateBps),
+                },
+            ],
+        };
+        const quoteResponse = await oneClickService_1.OneClickService.getQuote(quoteRequest);
+        const { quote } = quoteResponse;
+        if (!quote.depositAddress) {
+            throw new Error('Missing deposit address in quote response');
+        }
+        const { chainNamespace } = (0, caip_1.fromAssetId)(sellAsset.assetId);
+        const depositAddress = quote.depositAddress;
+        const getFeeData = async () => {
+            switch (chainNamespace) {
+                case caip_1.CHAIN_NAMESPACE.Evm: {
+                    try {
+                        const contractAddress = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
+                        const data = chain_adapters_1.evm.getErc20Data(depositAddress, sellAmount, contractAddress);
+                        const simulationResult = await (0, tenderly_1.simulateWithStateOverrides)({
+                            chainId: sellAsset.chainId,
+                            from: (0, viem_1.getAddress)(sendAddress || depositAddress),
+                            to: (0, viem_1.getAddress)(contractAddress ?? depositAddress),
+                            data: (data || '0x'),
+                            value: (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId) ? sellAmount : '0',
+                            sellAsset,
+                        }, {
+                            apiKey: deps.config.VITE_TENDERLY_API_KEY,
+                            accountSlug: deps.config.VITE_TENDERLY_ACCOUNT_SLUG,
+                            projectSlug: deps.config.VITE_TENDERLY_PROJECT_SLUG,
+                        });
+                        if (!simulationResult.success) {
+                            return '0';
+                        }
+                        // Calculate network fee using the simulated gas limit
+                        const sellAdapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+                        const { average } = await sellAdapter.getGasFeeData();
+                        const supportsEIP1559 = 'maxFeePerGas' in average;
+                        const networkFeeCryptoBaseUnit = chain_adapters_1.evm.calcNetworkFeeCryptoBaseUnit({
+                            ...average,
+                            supportsEIP1559,
+                            gasLimit: simulationResult.gasLimit.toString(),
+                        });
+                        return networkFeeCryptoBaseUnit;
+                    }
+                    catch (error) {
+                        return '0';
+                    }
+                }
+                case caip_1.CHAIN_NAMESPACE.Utxo: {
+                    const sellAdapter = deps.assertGetUtxoChainAdapter(sellAsset.chainId);
+                    const pubkey = input.xpub;
+                    if (!pubkey) {
+                        return undefined;
+                    }
+                    const feeData = await sellAdapter.getFeeData({
+                        to: depositAddress,
+                        value: sellAmount,
+                        chainSpecific: { pubkey },
+                        sendMax: false,
+                    });
+                    return feeData.fast.txFee;
+                }
+                case caip_1.CHAIN_NAMESPACE.Solana: {
+                    try {
+                        const sellAdapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+                        const tokenId = (0, utils_1.isToken)(sellAsset.assetId)
+                            ? (0, caip_1.fromAssetId)(sellAsset.assetId).assetReference
+                            : undefined;
+                        if (!sendAddress) {
+                            return '0';
+                        }
+                        const instructions = await sellAdapter.buildEstimationInstructions({
+                            from: sendAddress,
+                            to: depositAddress,
+                            tokenId,
+                            value: sellAmount,
+                        });
+                        const feeData = await sellAdapter.getFeeData({
+                            to: depositAddress,
+                            value: sellAmount,
+                            chainSpecific: {
+                                from: sendAddress,
+                                tokenId,
+                                instructions,
+                            },
+                            sendMax: false,
+                        });
+                        const txFee = feeData.fast.txFee;
+                        const ataCreationCost = (0, helpers_2.calculateAccountCreationCosts)(instructions);
+                        return (0, utils_1.bn)(txFee).plus(ataCreationCost).toString();
+                    }
+                    catch (error) {
+                        return '0';
+                    }
+                }
+                default:
+                    return undefined;
+            }
+        };
+        const networkFeeCryptoBaseUnit = (await getFeeData()) || '0';
+        const rate = (0, utils_2.getInputOutputRate)({
+            sellAmountCryptoBaseUnit: quote.amountIn,
+            buyAmountCryptoBaseUnit: quote.amountOut,
+            sellAsset,
+            buyAsset,
+        });
+        const tradeRate = {
+            id: (0, uuid_1.v4)(),
+            receiveAddress: receiveAddress ?? undefined,
+            affiliateBps,
+            rate,
+            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ??
+                (0, constants_1.getDefaultSlippageDecimalPercentageForSwapper)(types_1.SwapperName.NearIntents),
+            quoteOrRate: 'rate',
+            swapperName: types_1.SwapperName.NearIntents,
+            steps: [
+                {
+                    accountNumber: undefined,
+                    allowanceContract: '',
+                    buyAmountBeforeFeesCryptoBaseUnit: quote.amountOut,
+                    buyAmountAfterFeesCryptoBaseUnit: quote.amountOut,
+                    buyAsset,
+                    feeData: {
+                        protocolFees: {},
+                        networkFeeCryptoBaseUnit,
+                    },
+                    rate,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit: quote.amountIn,
+                    sellAsset,
+                    source: types_1.SwapperName.NearIntents,
+                    estimatedExecutionTimeMs: quote.timeEstimate ? quote.timeEstimate * 1000 : undefined,
+                },
+            ],
+        };
+        return (0, monads_1.Ok)([tradeRate]);
+    }
+    catch (error) {
+        if (error instanceof oneClickService_1.ApiError &&
+            (error.body?.message === 'tokenIn is not valid' ||
+                error.body?.message === 'tokenOut is not valid')) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                code: types_1.TradeQuoteError.UnsupportedTradePair,
+                message: 'Unsupported asset',
+            }));
+        }
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: error instanceof Error ? error.message : 'Unknown error getting NEAR Intents rate',
+            code: types_1.TradeQuoteError.QueryFailed,
+            cause: error,
+        }));
+    }
+};
+exports.getTradeRate = getTradeRate;

package/dist/cjs/swappers/NearIntentsSwapper/types.d.ts

@@ -0,0 +1,6 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export { QuoteRequest } from '@defuse-protocol/one-click-sdk-typescript';
+export type { QuoteResponse, GetExecutionStatusResponse, TokenResponse, } from '@defuse-protocol/one-click-sdk-typescript';
+export declare const nearIntentsSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.GnosisMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BitcoinMainnet, KnownChainIds.DogecoinMainnet, KnownChainIds.SolanaMainnet];
+export type NearIntentsSupportedChainId = (typeof nearIntentsSupportedChainIds)[number];
+export declare const chainIdToNearIntentsChain: Record<NearIntentsSupportedChainId, string>;

package/dist/cjs/swappers/NearIntentsSwapper/types.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chainIdToNearIntentsChain = exports.nearIntentsSupportedChainIds = exports.QuoteRequest = void 0;
+const types_1 = require("@shapeshiftoss/types");
+var one_click_sdk_typescript_1 = require("@defuse-protocol/one-click-sdk-typescript");
+Object.defineProperty(exports, "QuoteRequest", { enumerable: true, get: function () { return one_click_sdk_typescript_1.QuoteRequest; } });
+exports.nearIntentsSupportedChainIds = [
+    types_1.KnownChainIds.EthereumMainnet,
+    types_1.KnownChainIds.ArbitrumMainnet,
+    types_1.KnownChainIds.BaseMainnet,
+    types_1.KnownChainIds.GnosisMainnet,
+    types_1.KnownChainIds.BnbSmartChainMainnet,
+    types_1.KnownChainIds.PolygonMainnet,
+    types_1.KnownChainIds.AvalancheMainnet,
+    types_1.KnownChainIds.OptimismMainnet,
+    types_1.KnownChainIds.BitcoinMainnet,
+    types_1.KnownChainIds.DogecoinMainnet,
+    types_1.KnownChainIds.SolanaMainnet,
+];
+exports.chainIdToNearIntentsChain = {
+    [types_1.KnownChainIds.EthereumMainnet]: 'eth',
+    [types_1.KnownChainIds.ArbitrumMainnet]: 'arb',
+    [types_1.KnownChainIds.BaseMainnet]: 'base',
+    [types_1.KnownChainIds.GnosisMainnet]: 'gnosis',
+    [types_1.KnownChainIds.BnbSmartChainMainnet]: 'bsc',
+    [types_1.KnownChainIds.PolygonMainnet]: 'pol',
+    [types_1.KnownChainIds.AvalancheMainnet]: 'avax',
+    [types_1.KnownChainIds.OptimismMainnet]: 'op',
+    [types_1.KnownChainIds.BitcoinMainnet]: 'btc',
+    [types_1.KnownChainIds.DogecoinMainnet]: 'doge',
+    [types_1.KnownChainIds.SolanaMainnet]: 'sol',
+};

package/dist/cjs/swappers/NearIntentsSwapper/utils/helpers/helpers.d.ts

@@ -0,0 +1,12 @@
+import type { Asset } from '@shapeshiftoss/types';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import type { TransactionInstruction } from '@solana/web3.js';
+import type { GetExecutionStatusResponse } from '../../types';
+export declare const calculateAccountCreationCosts: (instructions: TransactionInstruction[]) => string;
+export declare const getNearIntentsAsset: ({ nearNetwork, contractAddress, }: {
+    nearNetwork: string;
+    contractAddress: string;
+}) => string;
+export declare const assetToNearIntentsAsset: (asset: Asset) => Promise<string | null>;
+export declare const mapNearIntentsStatus: (status: GetExecutionStatusResponse['status']) => TxStatus;
+export declare const getNearIntentsStatusMessage: (status: GetExecutionStatusResponse['status']) => string | undefined;

package/dist/cjs/swappers/NearIntentsSwapper/utils/helpers/helpers.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNearIntentsStatusMessage = exports.mapNearIntentsStatus = exports.assetToNearIntentsAsset = exports.getNearIntentsAsset = exports.calculateAccountCreationCosts = void 0;
+const token_1 = require("@coral-xyz/anchor/dist/cjs/utils/token");
+const caip_1 = require("@shapeshiftoss/caip");
+const unchained_client_1 = require("@shapeshiftoss/unchained-client");
+const utils_1 = require("@shapeshiftoss/utils");
+const viem_1 = require("viem");
+const types_1 = require("../../types");
+const oneClickService_1 = require("../oneClickService");
+const ATA_RENT_LAMPORTS = 2040000;
+const calculateAccountCreationCosts = (instructions) => {
+    let totalCost = (0, utils_1.bnOrZero)(0);
+    for (const ix of instructions) {
+        if (ix.programId.toString() === token_1.ASSOCIATED_PROGRAM_ID.toString()) {
+            totalCost = totalCost.plus(ATA_RENT_LAMPORTS);
+        }
+    }
+    return totalCost.toString();
+};
+exports.calculateAccountCreationCosts = calculateAccountCreationCosts;
+const getNearIntentsAsset = ({ nearNetwork, contractAddress, }) => {
+    // Native EVM assets: "nep141:eth.omft.near"
+    if (contractAddress === viem_1.zeroAddress) {
+        return `nep141:${nearNetwork}.omft.near`;
+    }
+    // ERC20 tokens: "nep141:eth-0x{address}.omft.near"
+    return `nep141:${nearNetwork}-${contractAddress.toLowerCase()}.omft.near`;
+};
+exports.getNearIntentsAsset = getNearIntentsAsset;
+const NEP245_CHAINS = ['bsc', 'pol', 'avax', 'op'];
+const assetToNearIntentsAsset = async (asset) => {
+    const nearNetwork = types_1.chainIdToNearIntentsChain[asset.chainId];
+    if (!nearNetwork)
+        return null;
+    // NEP-245 chains (BSC, Polygon, Avalanche, Optimism) and Solana require token lookup
+    // Asset IDs use hashed format that can't be generated from contract addresses
+    const requiresLookup = NEP245_CHAINS.includes(nearNetwork) || asset.chainId === caip_1.solanaChainId;
+    if (requiresLookup) {
+        const tokens = await oneClickService_1.OneClickService.getTokens();
+        const contractAddress = (0, utils_1.isToken)(asset.assetId)
+            ? (0, caip_1.fromAssetId)(asset.assetId).assetReference.toLowerCase()
+            : null;
+        const match = tokens.find((t) => {
+            if (t.blockchain !== nearNetwork)
+                return false;
+            return contractAddress
+                ? t.contractAddress?.toLowerCase() === contractAddress
+                : !t.contractAddress;
+        });
+        if (!match)
+            return null;
+        return match.assetId;
+    }
+    // NEP-141 chains (ETH, ARB, BASE, GNOSIS, BTC, DOGE): use predictable format
+    const contractAddress = (0, utils_1.isToken)(asset.assetId)
+        ? (0, caip_1.fromAssetId)(asset.assetId).assetReference
+        : viem_1.zeroAddress;
+    return (0, exports.getNearIntentsAsset)({ nearNetwork, contractAddress });
+};
+exports.assetToNearIntentsAsset = assetToNearIntentsAsset;
+const mapNearIntentsStatus = (status) => {
+    switch (status) {
+        case 'PENDING_DEPOSIT':
+        case 'KNOWN_DEPOSIT_TX':
+        case 'PROCESSING':
+            return unchained_client_1.TxStatus.Pending;
+        case 'SUCCESS':
+            return unchained_client_1.TxStatus.Confirmed;
+        case 'INCOMPLETE_DEPOSIT':
+        case 'REFUNDED':
+        case 'FAILED':
+            return unchained_client_1.TxStatus.Failed;
+        default:
+            return unchained_client_1.TxStatus.Unknown;
+    }
+};
+exports.mapNearIntentsStatus = mapNearIntentsStatus;
+const getNearIntentsStatusMessage = (status) => {
+    switch (status) {
+        case 'PENDING_DEPOSIT':
+            return 'Waiting for deposit...';
+        case 'KNOWN_DEPOSIT_TX':
+            return 'Deposit detected, waiting for confirmation...';
+        case 'PROCESSING':
+            return 'Processing swap...';
+        case 'SUCCESS':
+            return undefined;
+        case 'INCOMPLETE_DEPOSIT':
+            return 'Insufficient deposit amount';
+        case 'REFUNDED':
+            return 'Swap failed, funds refunded';
+        case 'FAILED':
+            return 'Swap failed';
+        default:
+            return 'Unknown status';
+    }
+};
+exports.getNearIntentsStatusMessage = getNearIntentsStatusMessage;

package/dist/cjs/swappers/NearIntentsSwapper/utils/oneClickService.d.ts

@@ -0,0 +1,3 @@
+import { ApiError, OneClickService } from '@defuse-protocol/one-click-sdk-typescript';
+export declare const initializeOneClickService: (apiKey: string) => void;
+export { ApiError, OneClickService };

package/dist/cjs/swappers/NearIntentsSwapper/utils/oneClickService.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneClickService = exports.ApiError = exports.initializeOneClickService = void 0;
+const one_click_sdk_typescript_1 = require("@defuse-protocol/one-click-sdk-typescript");
+Object.defineProperty(exports, "ApiError", { enumerable: true, get: function () { return one_click_sdk_typescript_1.ApiError; } });
+Object.defineProperty(exports, "OneClickService", { enumerable: true, get: function () { return one_click_sdk_typescript_1.OneClickService; } });
+const constants_1 = require("../constants");
+let isInitialized = false;
+const initializeOneClickService = (apiKey) => {
+    if (isInitialized)
+        return;
+    one_click_sdk_typescript_1.OpenAPI.BASE = constants_1.ONE_CLICK_BASE_URL;
+    one_click_sdk_typescript_1.OpenAPI.TOKEN = apiKey;
+    isInitialized = true;
+};
+exports.initializeOneClickService = initializeOneClickService;

package/dist/cjs/swappers/PortalsSwapper/getPortalsTradeRate/getPortalsTradeRate.js

@@ -10,12 +10,13 @@ const viem_1 = require("viem");
 const __1 = require("../../..");
 const types_1 = require("../../../types");
 const utils_2 = require("../../../utils");
+const tenderly_1 = require("../../../utils/tenderly");
 const helpers_1 = require("../../utils/helpers/helpers");
 const constants_1 = require("../constants");
 const fetchPortalsTradeOrder_1 = require("../utils/fetchPortalsTradeOrder");
 const helpers_2 = require("../utils/helpers");
 async function getPortalsTradeRate(input, assertGetEvmChainAdapter, swapperConfig) {
-    const { sellAsset, buyAsset, accountNumber, affiliateBps, chainId, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, } = input;
+    const { sellAsset, buyAsset, accountNumber, affiliateBps, chainId, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, supportsEIP1559, } = input;
     const adapter = assertGetEvmChainAdapter(chainId);
     const sellAssetChainId = sellAsset.chainId;
     const buyAssetChainId = buyAsset.chainId;
@@ -64,16 +65,32 @@ async function getPortalsTradeRate(input, assertGetEvmChainAdapter, swapperConfi
             : (0, utils_1.bnOrZero)((0, __1.getDefaultSlippageDecimalPercentageForSwapper)(types_1.SwapperName.Portals))
                 .times(100)
                 .toNumber();
-        const quoteEstimateResponse = await (0, fetchPortalsTradeOrder_1.fetchPortalsTradeEstimate)({
+        // Calculate affiliate fee percentage (e.g., 55 bps = 0.55%)
+        const affiliateBpsPercentage = (0, utils_1.convertBasisPointsToDecimalPercentage)(affiliateBps)
+            .times(100)
+            .toNumber();
+        // Dummy address for rates (no wallet connected yet)
+        // Using Vitalik's address as a realistic test address (same approach as Bebop)
+        const RATE_DUMMY_ADDRESS = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045';
+        // Use full quote endpoint (not estimate) to get transaction data for Tenderly simulation
+        // Skip validation since this is just a rate quote
+        const quoteResponse = await (0, fetchPortalsTradeOrder_1.fetchPortalsTradeOrder)({
+            sender: RATE_DUMMY_ADDRESS,
             inputToken,
             outputToken,
             inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
             slippageTolerancePercentage: userSlippageTolerancePercentageDecimalOrDefault,
+            partner: (0, helpers_1.getTreasuryAddressFromChainId)(chainId),
+            feePercentage: affiliateBpsPercentage,
+            validate: false,
             swapperConfig,
         });
-        // Estimate has no protocol fees, so after-fees = expected output amount
-        const buyAmountAfterFeesCryptoBaseUnit = quoteEstimateResponse.outputAmount;
-        // Use the quote estimate endpoint to get a quote without a wallet
+        if (!quoteResponse.tx) {
+            throw new Error('Portals quote response missing transaction data');
+        }
+        const { context, tx } = quoteResponse;
+        // Use outputAmount from context, not estimate
+        const buyAmountAfterFeesCryptoBaseUnit = context.outputAmount;
         const inputOutputRate = (0, utils_2.getInputOutputRate)({
             sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
             buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
@@ -83,21 +100,47 @@ async function getPortalsTradeRate(input, assertGetEvmChainAdapter, swapperConfi
         const allowanceContract = (0, helpers_2.getPortalsRouterAddressByChainId)(chainId);
         // Don't use Portals' slippageTolerancePercentage field (it's a price indicator, not actual buffer)
         // Instead, calculate the actual buffer Portals applied from the amounts
-        const actualBufferDecimal = (0, utils_1.bnOrZero)(quoteEstimateResponse.outputAmount)
-            .minus(quoteEstimateResponse.minOutputAmount)
-            .div(quoteEstimateResponse.outputAmount)
+        const actualBufferDecimal = (0, utils_1.bnOrZero)(context.outputAmount)
+            .minus(context.minOutputAmount)
+            .div(context.outputAmount)
             .toString();
         // Reverse the buffer to recover the expected output (minOutput / (1 - buffer) = output)
-        const buyAmountBeforeSlippageCryptoBaseUnit = (0, utils_1.bnOrZero)(quoteEstimateResponse.minOutputAmount)
+        const buyAmountBeforeSlippageCryptoBaseUnit = (0, utils_1.bnOrZero)(context.minOutputAmount)
             .div((0, utils_1.bn)(1).minus(actualBufferDecimal))
             .toFixed(0);
         const slippageTolerancePercentageDecimal = actualBufferDecimal;
-        const gasLimit = quoteEstimateResponse.context.gasLimit;
+        const gasLimit = await (async () => {
+            const tenderlySimulation = await (0, tenderly_1.simulateWithStateOverrides)({
+                chainId: sellAsset.chainId,
+                from: tx.from,
+                to: tx.to,
+                data: tx.data,
+                value: tx.value,
+                sellAsset,
+                spenderAddress: (0, viem_1.getAddress)(context.target),
+            }, {
+                apiKey: swapperConfig.VITE_TENDERLY_API_KEY,
+                accountSlug: swapperConfig.VITE_TENDERLY_ACCOUNT_SLUG,
+                projectSlug: swapperConfig.VITE_TENDERLY_PROJECT_SLUG,
+            });
+            if (tenderlySimulation.success) {
+                return tenderlySimulation.gasLimit.toString();
+            }
+            // Fallback to estimate endpoint (i.e simulation with overrides failed, but Portals still able to do their magic here)
+            const quoteEstimateResponse = await (0, fetchPortalsTradeOrder_1.fetchPortalsTradeEstimate)({
+                inputToken,
+                outputToken,
+                inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                slippageTolerancePercentage: userSlippageTolerancePercentageDecimalOrDefault,
+                swapperConfig,
+            });
+            return quoteEstimateResponse.context.gasLimit.toString();
+        })();
         const { average } = await adapter.getGasFeeData();
         const networkFeeCryptoBaseUnit = chain_adapters_1.evm.calcNetworkFeeCryptoBaseUnit({
             ...average,
-            supportsEIP1559: Boolean(input.supportsEIP1559),
-            gasLimit: gasLimit.toString(),
+            supportsEIP1559: Boolean(supportsEIP1559),
+            gasLimit,
         });
         const tradeRate = {
             id: (0, uuid_1.v4)(),

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

@@ -55,6 +55,7 @@ exports.DEFAULT_RELAY_SOLANA_USER_ADDRESS = 'CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn
 exports.MAXIMUM_SUPPORTED_RELAY_STEPS = 2;
 exports.relayErrorCodeToTradeQuoteError = {
     [types_3.RelayErrorCode.AmountTooLow]: types_2.TradeQuoteError.SellAmountBelowMinimum,
+    [types_3.RelayErrorCode.ChainDisabled]: types_2.TradeQuoteError.TradingHalted,
     [types_3.RelayErrorCode.Erc20RouterAddressNotFound]: types_2.TradeQuoteError.UnsupportedTradePair,
     [types_3.RelayErrorCode.ExtraTransactionsNotSupported]: types_2.TradeQuoteError.UnsupportedTradePair,
     [types_3.RelayErrorCode.InsufficientFunds]: types_2.TradeQuoteError.SellAmountBelowTradeFee,

package/dist/cjs/swappers/RelaySwapper/utils/fetchRelayTrade.d.ts

@@ -1,5 +1,5 @@
 import type { Result } from '@sniptt/monads';
 import type { AxiosResponse } from 'axios';
-import type { SwapErrorRight, SwapperConfig } from 'packages/swapper/src/types';
+import type { SwapErrorRight, SwapperConfig } from '../../../types';
 import type { RelayFetchQuoteParams, RelayQuote } from './types';
 export declare const fetchRelayTrade: <T extends "rate" | "quote">(params: RelayFetchQuoteParams<T>, config: SwapperConfig) => Promise<Result<AxiosResponse<RelayQuote, any>, SwapErrorRight>>;

package/dist/cjs/swappers/RelaySwapper/utils/getRelayPsbtRelayer.js

@@ -27,7 +27,7 @@ exports.getRelayPsbtRelayer = void 0;
 const bitcoin = __importStar(require("@shapeshiftoss/bitcoinjs-lib"));
 const getRelayPsbtRelayer = (psbtHex, sellAmountCryptoBaseUnit) => {
     const psbtBuffer = Buffer.from(psbtHex, 'hex');
-    const psbt = bitcoin.Psbt.fromBuffer(new Uint8Array(psbtBuffer));
+    const psbt = bitcoin.Psbt.fromBuffer(psbtBuffer);
     const outputs = psbt.txOutputs;
     for (let i = 0; i < outputs.length; i++) {
         const output = outputs[i];
@@ -35,7 +35,7 @@ const getRelayPsbtRelayer = (psbtHex, sellAmountCryptoBaseUnit) => {
         try {
             const address = bitcoin.address.fromOutputScript(script);
             // Assuming the destination address is the one with the exact amount of sellAmountCryptoBaseUnit
-            if (output.value === BigInt(sellAmountCryptoBaseUnit)) {
+            if (output.value === Number(sellAmountCryptoBaseUnit)) {
                 return address;
             }
         }

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

@@ -13,6 +13,7 @@ const axios_1 = __importDefault(require("axios"));
 const viem_1 = require("viem");
 const types_1 = require("../../../types");
 const utils_2 = require("../../../utils");
+const tenderly_1 = require("../../../utils/tenderly");
 const helpers_1 = require("../../utils/helpers/helpers");
 const constant_1 = require("../constant");
 const getRelayAssetAddress_1 = require("../utils/getRelayAssetAddress");
@@ -132,6 +133,11 @@ async function getTrade({ input, deps, relayChainMap, }) {
                 code: tradeQuoteErrorCode,
             }));
         }
+        // Fallback for unmapped error codes (shouldn't happen, but prevents crashes)
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: relayError.message || 'Unknown Relay error',
+            code: types_1.TradeQuoteError.UnknownError,
+        }));
     }
     const { data: quote } = maybeQuote.unwrap();
     const { slippageTolerance, currencyOut, timeEstimate } = quote.details;
@@ -333,6 +339,45 @@ async function getTrade({ input, deps, relayChainMap, }) {
             const feeData = await adapter.getFeeData(getFeeDataInput);
             return feeData.fast.txFee;
         }
+        // Use Tenderly simulation with state overrides for EVM chains
+        if ((0, chain_adapters_1.isEvmChainId)(sellAsset.chainId)) {
+            const firstStep = swapSteps[0];
+            const selectedItem = firstStep?.items?.[0];
+            if (selectedItem?.data && (0, types_2.isRelayQuoteEvmItemData)(selectedItem.data)) {
+                try {
+                    const tenderlySimulation = await (0, tenderly_1.simulateWithStateOverrides)({
+                        chainId: sellAsset.chainId,
+                        // NOTE: zeroAddress is here purely for the purpose of satisfying the type sistem
+                        // That should never happen
+                        from: (0, viem_1.getAddress)(sendAddress ?? viem_1.zeroAddress),
+                        to: (0, viem_1.getAddress)(selectedItem.data.to ?? viem_1.zeroAddress),
+                        data: (selectedItem.data.data ?? '0x'),
+                        value: selectedItem.data.value ?? '0',
+                        sellAsset,
+                    }, {
+                        apiKey: deps.config.VITE_TENDERLY_API_KEY,
+                        accountSlug: deps.config.VITE_TENDERLY_ACCOUNT_SLUG,
+                        projectSlug: deps.config.VITE_TENDERLY_PROJECT_SLUG,
+                    });
+                    if (tenderlySimulation.success) {
+                        // Use Tenderly's gas estimate instead of Relay's
+                        const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+                        const { average } = await adapter.getGasFeeData();
+                        const supportsEIP1559 = 'maxFeePerGas' in average;
+                        const tenderlyNetworkFee = chain_adapters_1.evm.calcNetworkFeeCryptoBaseUnit({
+                            ...average,
+                            supportsEIP1559,
+                            gasLimit: tenderlySimulation.gasLimit.toString(),
+                        });
+                        return tenderlyNetworkFee;
+                    }
+                }
+                catch (error) {
+                    // Silently fall through to use Relay's gas estimate
+                }
+            }
+        }
+        // Fallback to Relay's gas amount
         return quote.fees.gas.amount;
     })();
     const steps = swapSteps.map((quoteStep) => {

package/dist/cjs/swappers/RelaySwapper/utils/notifyTransactionIndexing.d.ts

@@ -1,6 +1,6 @@
 import type { Result } from '@sniptt/monads';
 import type { AxiosResponse } from 'axios';
-import type { SwapErrorRight, SwapperConfig } from 'packages/swapper/src/types';
+import type { SwapErrorRight, SwapperConfig } from '../../../types';
 import type { RelayQuote } from './types';
 type NotifyTransactionIndexingParams = {
     requestId: string;

package/dist/cjs/swappers/RelaySwapper/utils/relayTokenToAssetId.js

@@ -23,8 +23,6 @@ const relayTokenToAssetId = (relayToken) => {
         if (!isNativeAsset) {
             const assetNamespace = (() => {
                 switch (true) {
-                    case caip_1.CHAIN_REFERENCE.BnbSmartChainMainnet === chainReference:
-                        return caip_1.ASSET_NAMESPACE.bep20;
                     case (0, chain_adapters_1.isEvmChainId)(chainId):
                         return caip_1.ASSET_NAMESPACE.erc20;
                     case caip_1.CHAIN_REFERENCE.SolanaMainnet === chainReference:

package/dist/cjs/swappers/RelaySwapper/utils/types.d.ts

@@ -131,6 +131,7 @@ export type RelaySolanaInstruction = {
 };
 export declare enum RelayErrorCode {
     AmountTooLow = "AMOUNT_TOO_LOW",
+    ChainDisabled = "CHAIN_DISABLED",
     Erc20RouterAddressNotFound = "ERC20_ROUTER_ADDRESS_NOT_FOUND",
     ExtraTransactionsNotSupported = "EXTRA_TXS_NOT_SUPPORTED",
     InsufficientFunds = "INSUFFICIENT_FUNDS",

package/dist/cjs/swappers/RelaySwapper/utils/types.js

@@ -16,6 +16,7 @@ exports.isRelayQuoteSolanaItemData = isRelayQuoteSolanaItemData;
 var RelayErrorCode;
 (function (RelayErrorCode) {
     RelayErrorCode["AmountTooLow"] = "AMOUNT_TOO_LOW";
+    RelayErrorCode["ChainDisabled"] = "CHAIN_DISABLED";
     RelayErrorCode["Erc20RouterAddressNotFound"] = "ERC20_ROUTER_ADDRESS_NOT_FOUND";
     RelayErrorCode["ExtraTransactionsNotSupported"] = "EXTRA_TXS_NOT_SUPPORTED";
     RelayErrorCode["InsufficientFunds"] = "INSUFFICIENT_FUNDS";