@shapeshiftoss/swapper 17.6.6 → 17.6.8

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

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.portalsApi = 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 getPortalsTradeQuote_1 = require("./getPortalsTradeQuote/getPortalsTradeQuote");
+const getPortalsTradeRate_1 = require("./getPortalsTradeRate/getPortalsTradeRate");
+const fetchAxelarscanStatus_1 = require("./utils/fetchAxelarscanStatus");
+const fetchSquidStatus_1 = require("./utils/fetchSquidStatus");
+exports.portalsApi = {
+    getTradeQuote: async (input, { config, assertGetEvmChainAdapter }) => {
+        const tradeQuoteResult = await (0, getPortalsTradeQuote_1.getPortalsTradeQuote)(input, assertGetEvmChainAdapter, config);
+        return tradeQuoteResult.map(tradeQuote => [tradeQuote]);
+    },
+    getTradeRate: async (input, { config, assertGetEvmChainAdapter }) => {
+        const tradeRateResult = await (0, getPortalsTradeRate_1.getPortalsTradeRate)(input, assertGetEvmChainAdapter, config);
+        return tradeRateResult.map(tradeRate => [tradeRate]);
+    },
+    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 { portalsTransactionMetadata, sellAsset } = step;
+        if (!portalsTransactionMetadata)
+            throw new Error('Transaction metadata is required');
+        const { value, to, data } = portalsTransactionMetadata;
+        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+        const feeData = await chain_adapters_1.evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
+        return feeData.networkFeeCryptoBaseUnit;
+    },
+    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, portalsTransactionMetadata, sellAsset } = step;
+        if (!portalsTransactionMetadata)
+            throw new Error('Transaction metadata is required');
+        // Portals has a 15% buffer on gas estimations, which may or may not turn out to be more reliable than our "pure" simulations
+        const { value, to, data, gasLimit: estimatedGas } = portalsTransactionMetadata;
+        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+        const feeData = await chain_adapters_1.evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
+        return adapter.buildCustomApiTx({
+            accountNumber,
+            data,
+            from,
+            to,
+            value,
+            ...feeData,
+            // Use the higher amount of the node or the API, as the node doesn't always provide enough gas padding for total gas used.
+            gasLimit: bignumber_js_1.default.max(feeData.gasLimit, estimatedGas).toFixed(),
+        });
+    },
+    checkTradeStatus: async (input) => {
+        const { txHash, chainId, swap, assertGetEvmChainAdapter, address, fetchIsSmartContractAddressQuery, } = input;
+        const isCrossChain = Boolean(swap && swap.sellAsset.chainId !== swap.buyAsset?.chainId);
+        if (!isCrossChain) {
+            return (0, utils_1.checkEvmSwapStatus)({
+                txHash,
+                chainId,
+                address,
+                assertGetEvmChainAdapter,
+                fetchIsSmartContractAddressQuery,
+            });
+        }
+        const sourceTxStatus = await (0, utils_1.checkEvmSwapStatus)({
+            txHash,
+            chainId,
+            address,
+            assertGetEvmChainAdapter,
+            fetchIsSmartContractAddressQuery,
+        });
+        if (sourceTxStatus.status === unchained_client_1.TxStatus.Pending || sourceTxStatus.status === unchained_client_1.TxStatus.Unknown) {
+            return {
+                status: unchained_client_1.TxStatus.Pending,
+                buyTxHash: undefined,
+                message: 'Source transaction pending',
+            };
+        }
+        if (sourceTxStatus.status === unchained_client_1.TxStatus.Failed) {
+            return sourceTxStatus;
+        }
+        const axelarscanResult = await (0, fetchAxelarscanStatus_1.fetchAxelarscanBridgeStatus)(txHash);
+        if ((axelarscanResult.isErr() || !axelarscanResult.unwrap()) && swap) {
+            const squidResult = await (0, fetchSquidStatus_1.fetchSquidBridgeStatus)(txHash, swap.sellAsset.chainId, swap.buyAsset.chainId);
+            if (squidResult.isOk()) {
+                const squidStatus = squidResult.unwrap();
+                const squidTxStatus = (() => {
+                    switch (squidStatus.status) {
+                        case 'confirmed':
+                            return unchained_client_1.TxStatus.Confirmed;
+                        case 'failed':
+                            return unchained_client_1.TxStatus.Failed;
+                        case 'pending':
+                        default:
+                            return unchained_client_1.TxStatus.Pending;
+                    }
+                })();
+                return {
+                    status: squidTxStatus,
+                    buyTxHash: squidStatus.destinationTxHash,
+                    relayerExplorerTxLink: (0, fetchSquidStatus_1.getSquidTrackingLink)(txHash, squidStatus, swap.sellAsset.explorerTxLink, swap.buyAsset.explorerTxLink),
+                    message: squidTxStatus === unchained_client_1.TxStatus.Pending ? 'Cross-chain swap in progress' : undefined,
+                };
+            }
+            return {
+                status: unchained_client_1.TxStatus.Pending,
+                buyTxHash: undefined,
+                relayerExplorerTxLink: (0, fetchAxelarscanStatus_1.getAxelarscanTrackingLink)(txHash),
+                message: 'Bridge status check failed - track manually',
+            };
+        }
+        const bridgeStatus = axelarscanResult.unwrap();
+        if (!bridgeStatus) {
+            return {
+                status: unchained_client_1.TxStatus.Pending,
+                buyTxHash: undefined,
+                message: 'Cross-chain swap in progress',
+            };
+        }
+        const txStatus = (() => {
+            switch (bridgeStatus.status) {
+                case 'confirmed':
+                    return unchained_client_1.TxStatus.Confirmed;
+                case 'failed':
+                    return unchained_client_1.TxStatus.Failed;
+                case 'pending':
+                default:
+                    return unchained_client_1.TxStatus.Pending;
+            }
+        })();
+        return {
+            status: txStatus,
+            buyTxHash: bridgeStatus.destinationTxHash,
+            relayerExplorerTxLink: (0, fetchAxelarscanStatus_1.getAxelarscanTrackingLink)(txHash),
+            message: txStatus === unchained_client_1.TxStatus.Pending
+                ? 'Bridge in progress'
+                : txStatus === unchained_client_1.TxStatus.Failed
+                    ? bridgeStatus.errorMessage
+                    : undefined,
+        };
+    },
+};

package/dist/cjs/swappers/PortalsSwapper/getPortalsTradeQuote/getPortalsTradeQuote.d.ts

@@ -0,0 +1,5 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+import type { EvmChainAdapter } from '@shapeshiftoss/chain-adapters';
+import type { Result } from '@sniptt/monads';
+import type { GetEvmTradeQuoteInputBase, SwapErrorRight, SwapperConfig, TradeQuote } from '../../../types';
+export declare function getPortalsTradeQuote(input: GetEvmTradeQuoteInputBase, assertGetEvmChainAdapter: (chainId: ChainId) => EvmChainAdapter, swapperConfig: SwapperConfig): Promise<Result<TradeQuote, SwapErrorRight>>;

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

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPortalsTradeQuote = 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 viem_1 = require("viem");
+const __1 = require("../../..");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+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 getPortalsTradeQuote(input, assertGetEvmChainAdapter, swapperConfig) {
+    const { sellAsset, buyAsset, sendAddress, accountNumber, affiliateBps, chainId, supportsEIP1559, sellAmountIncludingProtocolFeesCryptoBaseUnit, } = input;
+    const sellAssetChainId = sellAsset.chainId;
+    const buyAssetChainId = buyAsset.chainId;
+    if (!(0, helpers_2.isSupportedChainId)(sellAssetChainId)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!(0, helpers_2.isSupportedChainId)(buyAssetChainId)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: buyAsset.chainId },
+        }));
+    }
+    const isCrossChain = sellAssetChainId !== buyAssetChainId;
+    // Not a decimal percentage, just a good ol' percentage e.g 1 for 1%
+    const affiliateBpsPercentage = (0, utils_1.convertBasisPointsToDecimalPercentage)(affiliateBps)
+        .times(100)
+        .toNumber();
+    const userSlippageTolerancePercentageDecimalOrDefault = input.slippageTolerancePercentageDecimal
+        ? (0, utils_1.bnOrZero)(input.slippageTolerancePercentageDecimal).times(100).toNumber()
+        : (0, utils_1.bnOrZero)((0, __1.getDefaultSlippageDecimalPercentageForSwapper)(types_1.SwapperName.Portals))
+            .times(100)
+            .toNumber();
+    if (!sendAddress)
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({ message: 'missing sendAddress' }));
+    const sellPortalsNetwork = constants_1.chainIdToPortalsNetwork[sellAssetChainId];
+    const buyPortalsNetwork = constants_1.chainIdToPortalsNetwork[buyAssetChainId];
+    if (!sellPortalsNetwork) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `unsupported ChainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAssetChainId },
+        }));
+    }
+    if (!buyPortalsNetwork) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `unsupported ChainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: buyAssetChainId },
+        }));
+    }
+    const sellAssetAddress = (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId)
+        ? viem_1.zeroAddress
+        : (0, caip_1.fromAssetId)(sellAsset.assetId).assetReference;
+    const buyAssetAddress = (0, helpers_1.isNativeEvmAsset)(buyAsset.assetId)
+        ? viem_1.zeroAddress
+        : (0, caip_1.fromAssetId)(buyAsset.assetId).assetReference;
+    const inputToken = `${sellPortalsNetwork}:${sellAssetAddress}`;
+    const outputToken = `${buyPortalsNetwork}:${buyAssetAddress}`;
+    try {
+        const maybePortalsTradeOrderResponse = await (0, fetchPortalsTradeOrder_1.fetchPortalsTradeOrder)({
+            sender: sendAddress,
+            inputToken,
+            outputToken,
+            inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            slippageTolerancePercentage: userSlippageTolerancePercentageDecimalOrDefault,
+            partner: (0, helpers_1.getTreasuryAddressFromChainId)(sellAsset.chainId),
+            feePercentage: affiliateBpsPercentage,
+            validate: true,
+            swapperConfig,
+        })
+            .then(res => (0, monads_1.Ok)(res))
+            .catch(async (err) => {
+            if (err instanceof fetchPortalsTradeOrder_1.PortalsError) {
+                // We assume a PortalsError was thrown because the slippage tolerance was too high during simulation
+                // So we attempt another (failing) call with autoslippage which will give us the actual expected slippage
+                const portalsExpectedSlippage = await (0, fetchPortalsTradeOrder_1.fetchPortalsTradeOrder)({
+                    sender: sendAddress,
+                    inputToken,
+                    outputToken,
+                    inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    autoSlippage: true,
+                    partner: (0, helpers_1.getTreasuryAddressFromChainId)(sellAsset.chainId),
+                    feePercentage: affiliateBpsPercentage,
+                    validate: true,
+                    swapperConfig,
+                })
+                    // This should never happen but could in very rare cases if original call failed on slippage slightly over 2.5% but this one succeeds on slightly under 2.5%
+                    .then(res => res.context.slippageTolerancePercentage)
+                    .catch(err => err.message.match(/Expected slippage is (.*?)%/)?.[1]);
+                // This should never happen as we don't have auto-slippage on for `/portal` as of now (2024-12-06, see https://github.com/shapeshift/web/pull/8293)
+                // But as soon as Portals implement auto-slippage for the estimate endpoint, we will most likely re-enable it, assuming it actually works
+                if (err.message.includes('Auto slippage exceeds'))
+                    return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                        message: err.message,
+                        details: {
+                            expectedSlippage: portalsExpectedSlippage
+                                ? (0, utils_1.bn)(portalsExpectedSlippage).toFixed(2, utils_1.BigNumber.ROUND_HALF_UP)
+                                : undefined,
+                        },
+                        cause: err,
+                        code: types_1.TradeQuoteError.FinalQuoteMaxSlippageExceeded,
+                    }));
+                if (err.message.includes('execution reverted'))
+                    return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                        message: err.message,
+                        details: {
+                            expectedSlippage: portalsExpectedSlippage
+                                ? (0, utils_1.bn)(portalsExpectedSlippage).toFixed(2, utils_1.BigNumber.ROUND_HALF_UP)
+                                : undefined,
+                        },
+                        cause: err,
+                        code: types_1.TradeQuoteError.FinalQuoteExecutionReverted,
+                    }));
+            }
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: 'failed to get Portals quote',
+                cause: err,
+                code: types_1.TradeQuoteError.NetworkFeeEstimationFailed,
+            }));
+        });
+        if (maybePortalsTradeOrderResponse.isErr())
+            return (0, monads_1.Err)(maybePortalsTradeOrderResponse.unwrapErr());
+        const portalsTradeOrderResponse = maybePortalsTradeOrderResponse.unwrap();
+        const { context: { orderId, outputAmount, minOutputAmount, target, feeAmount, gasLimit, feeToken }, tx, } = portalsTradeOrderResponse;
+        const allowanceContract = isCrossChain ? target : (0, helpers_2.getPortalsRouterAddressByChainId)(chainId);
+        const buyAmountAfterFeesCryptoBaseUnit = isCrossChain ? minOutputAmount : outputAmount;
+        const protocolFeeAsset = feeToken === inputToken ? sellAsset : buyAsset;
+        if (!tx)
+            throw new Error('Portals Tx simulation failed upstream');
+        const inputOutputRate = (0, utils_2.getInputOutputRate)({
+            sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const adapter = assertGetEvmChainAdapter(chainId);
+        const { average } = await adapter.getGasFeeData();
+        const networkFeeCryptoBaseUnit = chain_adapters_1.evm.calcNetworkFeeCryptoBaseUnit({
+            ...average,
+            supportsEIP1559: Boolean(supportsEIP1559),
+            // times 1 isn't a mistake, it's just so we can write this comment above to mention that Portals already add a
+            // buffer of ~15% to the gas limit
+            gasLimit: (0, utils_1.bnOrZero)(gasLimit).times(1).toFixed(),
+        });
+        // Don't use Portals' slippageTolerancePercentage field (it's what we requested, not what they applied)
+        // Instead, calculate the actual buffer Portals applied from the amounts
+        const actualBufferDecimal = (0, utils_1.bnOrZero)(buyAmountAfterFeesCryptoBaseUnit)
+            .minus(minOutputAmount)
+            .div(buyAmountAfterFeesCryptoBaseUnit)
+            .toString();
+        // Reverse the buffer to recover the expected output (minOutput / (1 - buffer) = output)
+        const buyAmountBeforeSlippageCryptoBaseUnit = (0, utils_1.bnOrZero)(minOutputAmount)
+            .div((0, utils_1.bn)(1).minus(actualBufferDecimal))
+            .toFixed(0);
+        const slippageTolerancePercentageDecimal = actualBufferDecimal;
+        const tradeQuote = {
+            id: orderId,
+            quoteOrRate: 'quote',
+            receiveAddress: input.receiveAddress,
+            affiliateBps,
+            rate: inputOutputRate,
+            slippageTolerancePercentageDecimal,
+            swapperName: types_1.SwapperName.Portals,
+            steps: [
+                {
+                    accountNumber,
+                    allowanceContract,
+                    rate: inputOutputRate,
+                    buyAsset,
+                    sellAsset,
+                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountBeforeSlippageCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    feeData: {
+                        networkFeeCryptoBaseUnit,
+                        protocolFees: {
+                            [protocolFeeAsset.assetId]: {
+                                amountCryptoBaseUnit: feeAmount,
+                                asset: protocolFeeAsset,
+                                requiresBalance: false,
+                            },
+                        },
+                    },
+                    source: types_1.SwapperName.Portals,
+                    estimatedExecutionTimeMs: isCrossChain ? 300000 : 0,
+                    portalsTransactionMetadata: {
+                        ...tx,
+                        isCrossChain,
+                        buyAssetChainId: isCrossChain ? buyAssetChainId : undefined,
+                        expiry: portalsTradeOrderResponse.context.expiry
+                            ? Number(portalsTradeOrderResponse.context.expiry)
+                            : undefined,
+                        steps: portalsTradeOrderResponse.context.steps,
+                        route: portalsTradeOrderResponse.context.route,
+                    },
+                },
+            ],
+        };
+        return (0, monads_1.Ok)(tradeQuote);
+    }
+    catch (err) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'failed to get Portals quote',
+            cause: err,
+            code: types_1.TradeQuoteError.NetworkFeeEstimationFailed,
+        }));
+    }
+}
+exports.getPortalsTradeQuote = getPortalsTradeQuote;

package/dist/cjs/swappers/PortalsSwapper/getPortalsTradeRate/getPortalsTradeRate.d.ts

@@ -0,0 +1,5 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+import type { EvmChainAdapter } from '@shapeshiftoss/chain-adapters';
+import type { Result } from '@sniptt/monads';
+import type { GetEvmTradeRateInput, SwapErrorRight, SwapperConfig, TradeRate } from '../../../types';
+export declare function getPortalsTradeRate(input: GetEvmTradeRateInput, assertGetEvmChainAdapter: (chainId: ChainId) => EvmChainAdapter, swapperConfig: SwapperConfig): Promise<Result<TradeRate, SwapErrorRight>>;

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

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPortalsTradeRate = 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 __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, supportsEIP1559, } = input;
+    const adapter = assertGetEvmChainAdapter(chainId);
+    const sellAssetChainId = sellAsset.chainId;
+    const buyAssetChainId = buyAsset.chainId;
+    if (!(0, helpers_2.isSupportedChainId)(sellAssetChainId)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!(0, helpers_2.isSupportedChainId)(buyAssetChainId)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    const isCrossChain = sellAssetChainId !== buyAssetChainId;
+    try {
+        if (!(0, helpers_2.isSupportedChainId)(chainId))
+            throw new Error(`Unsupported chainId ${sellAsset.chainId}`);
+        const sellPortalsNetwork = constants_1.chainIdToPortalsNetwork[sellAssetChainId];
+        const buyPortalsNetwork = constants_1.chainIdToPortalsNetwork[buyAssetChainId];
+        if (!sellPortalsNetwork) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: `unsupported ChainId`,
+                code: types_1.TradeQuoteError.UnsupportedChain,
+                details: { chainId: sellAssetChainId },
+            }));
+        }
+        if (!buyPortalsNetwork) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: `unsupported ChainId`,
+                code: types_1.TradeQuoteError.UnsupportedChain,
+                details: { chainId: buyAssetChainId },
+            }));
+        }
+        const sellAssetAddress = (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId)
+            ? viem_1.zeroAddress
+            : (0, caip_1.fromAssetId)(sellAsset.assetId).assetReference;
+        const buyAssetAddress = (0, helpers_1.isNativeEvmAsset)(buyAsset.assetId)
+            ? viem_1.zeroAddress
+            : (0, caip_1.fromAssetId)(buyAsset.assetId).assetReference;
+        const inputToken = `${sellPortalsNetwork}:${sellAssetAddress}`;
+        const outputToken = `${buyPortalsNetwork}:${buyAssetAddress}`;
+        const userSlippageTolerancePercentageDecimalOrDefault = input.slippageTolerancePercentageDecimal
+            ? (0, utils_1.bnOrZero)(input.slippageTolerancePercentageDecimal).times(100).toNumber()
+            : (0, utils_1.bnOrZero)((0, __1.getDefaultSlippageDecimalPercentageForSwapper)(types_1.SwapperName.Portals))
+                .times(100)
+                .toNumber();
+        // 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,
+        });
+        if (!quoteResponse.tx) {
+            throw new Error('Portals quote response missing transaction data');
+        }
+        const { context, tx } = quoteResponse;
+        const buyAmountAfterFeesCryptoBaseUnit = isCrossChain
+            ? context.minOutputAmount
+            : context.outputAmount;
+        const inputOutputRate = (0, utils_2.getInputOutputRate)({
+            sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const allowanceContract = isCrossChain
+            ? context.target
+            : (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)(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)(context.minOutputAmount)
+            .div((0, utils_1.bn)(1).minus(actualBufferDecimal))
+            .toFixed(0);
+        const slippageTolerancePercentageDecimal = actualBufferDecimal;
+        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(supportsEIP1559),
+            gasLimit,
+        });
+        const tradeRate = {
+            id: (0, uuid_1.v4)(),
+            quoteOrRate: 'rate',
+            accountNumber,
+            receiveAddress,
+            affiliateBps,
+            rate: inputOutputRate,
+            slippageTolerancePercentageDecimal,
+            swapperName: types_1.SwapperName.Portals,
+            steps: [
+                {
+                    estimatedExecutionTimeMs: isCrossChain ? 300000 : 0,
+                    allowanceContract,
+                    accountNumber,
+                    rate: inputOutputRate,
+                    buyAsset,
+                    sellAsset,
+                    // Before slippage on the right vs. before fees on the left is not a mistake.
+                    // Portals will yield different `outputAmount` (expected out) on estimate vs. quote and is an upstream bug, so we can't use that
+                    // To circumvent that and not mislead users into very optimistic expected out in rate (not taking slippage into account) but pessimistic in rate in the end,
+                    // we simply add the slippage back to the min out, which yields values very close to the actual quote amounts (with a small upside on the quote, so users actually get a better quote
+                    // than what they've seen as a rate, which is much better than a *huge* downside on the quote)
+                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountBeforeSlippageCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    feeData: {
+                        networkFeeCryptoBaseUnit,
+                        protocolFees: undefined, // We don't have protocol fees on Portals during the estimate step
+                    },
+                    source: types_1.SwapperName.Portals,
+                },
+            ],
+        };
+        return (0, monads_1.Ok)(tradeRate);
+    }
+    catch (err) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'failed to get Portals quote',
+            cause: err,
+            code: types_1.TradeQuoteError.NetworkFeeEstimationFailed,
+        }));
+    }
+}
+exports.getPortalsTradeRate = getPortalsTradeRate;

package/dist/cjs/swappers/PortalsSwapper/index.d.ts

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './types';

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

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants"), exports);
+__exportStar(require("./types"), exports);

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

@@ -0,0 +1,3 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export declare const PortalsSupportedChainIds: KnownChainIds[];
+export type PortalsSupportedChainId = (typeof PortalsSupportedChainIds)[number];

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PortalsSupportedChainIds = void 0;
+const types_1 = require("@shapeshiftoss/types");
+// https://api.portals.fi/v1/networks
+exports.PortalsSupportedChainIds = [
+    types_1.KnownChainIds.EthereumMainnet,
+    types_1.KnownChainIds.ArbitrumMainnet,
+    types_1.KnownChainIds.AvalancheMainnet,
+    types_1.KnownChainIds.PolygonMainnet,
+    types_1.KnownChainIds.BnbSmartChainMainnet,
+    types_1.KnownChainIds.OptimismMainnet,
+    types_1.KnownChainIds.GnosisMainnet,
+    types_1.KnownChainIds.BaseMainnet,
+    types_1.KnownChainIds.HyperEvmMainnet,
+];

package/dist/cjs/swappers/PortalsSwapper/utils/fetchAxelarscanStatus.d.ts

@@ -0,0 +1,9 @@
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types';
+export type AxelarscanBridgeStatus = {
+    status: 'pending' | 'confirmed' | 'failed';
+    destinationTxHash?: string;
+    errorMessage?: string;
+};
+export declare const fetchAxelarscanBridgeStatus: (sourceTxHash: string) => Promise<Result<AxelarscanBridgeStatus | undefined, SwapErrorRight>>;
+export declare const getAxelarscanTrackingLink: (sourceTxHash: string) => string;