@shapeshiftoss/swapper 17.8.0 → 18.1.0

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

@@ -1,226 +1,142 @@
-import { fromAssetId } from '@shapeshiftoss/caip';
-import { evm } from '@shapeshiftoss/chain-adapters';
-import { BigNumber, bn, bnOrZero, convertBasisPointsToDecimalPercentage, } from '@shapeshiftoss/utils';
+import { BigNumber, bn } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
-import { zeroAddress } from 'viem';
-import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../index.js';
-import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
-import { buildAffiliateFee } from '../../utils/affiliateFee.js';
-import { getTreasuryAddressFromChainId, isNativeEvmAsset } from '../../utils/helpers/helpers.js';
-import { chainIdToPortalsNetwork } from '../constants.js';
+import { TradeQuoteError } from '../../../types.js';
+import { assertQuoteAddresses, makeSwapErrorRight, makeTradeStepBuildFailedErr, } from '../../../utils/index.js';
+import { getTreasuryAddressFromChainId } from '../../../utils/helpers.js';
 import { fetchPortalsTradeOrder, PortalsError } from '../utils/fetchPortalsTradeOrder.js';
-import { getPortalsRouterAddressByChainId, isSupportedChainId } from '../utils/helpers.js';
-export 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 (!isSupportedChainId(sellAssetChainId)) {
-        return Err(makeSwapErrorRight({
-            message: `unsupported chainId`,
-            code: TradeQuoteError.UnsupportedChain,
-            details: { chainId: sellAsset.chainId },
-        }));
-    }
-    if (!isSupportedChainId(buyAssetChainId)) {
-        return Err(makeSwapErrorRight({
-            message: `unsupported chainId`,
-            code: 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 = convertBasisPointsToDecimalPercentage(affiliateBps)
-        .times(100)
-        .toNumber();
-    const userSlippageTolerancePercentageDecimalOrDefault = input.slippageTolerancePercentageDecimal
-        ? bnOrZero(input.slippageTolerancePercentageDecimal).times(100).toNumber()
-        : bnOrZero(getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Portals))
-            .times(100)
-            .toNumber();
-    if (!sendAddress)
-        return Err(makeSwapErrorRight({ message: 'missing sendAddress' }));
-    const sellPortalsNetwork = chainIdToPortalsNetwork[sellAssetChainId];
-    const buyPortalsNetwork = chainIdToPortalsNetwork[buyAssetChainId];
-    if (!sellPortalsNetwork) {
-        return Err(makeSwapErrorRight({
-            message: `unsupported ChainId`,
-            code: TradeQuoteError.UnsupportedChain,
-            details: { chainId: sellAssetChainId },
-        }));
-    }
-    if (!buyPortalsNetwork) {
-        return Err(makeSwapErrorRight({
-            message: `unsupported ChainId`,
-            code: TradeQuoteError.UnsupportedChain,
-            details: { chainId: buyAssetChainId },
-        }));
-    }
-    const sellAssetAddress = isNativeEvmAsset(sellAsset.assetId)
-        ? zeroAddress
-        : fromAssetId(sellAsset.assetId).assetReference;
-    const buyAssetAddress = isNativeEvmAsset(buyAsset.assetId)
-        ? zeroAddress
-        : fromAssetId(buyAsset.assetId).assetReference;
-    const inputToken = `${sellPortalsNetwork}:${sellAssetAddress}`;
-    const outputToken = `${buyPortalsNetwork}:${buyAssetAddress}`;
-    try {
-        const maybePortalsTradeOrderResponse = await fetchPortalsTradeOrder({
+import { getPortalsStepData } from '../utils/getPortalsStepData.js';
+import { getPortalsTradeContext } from '../utils/getPortalsTradeContext.js';
+import { assertValidTrade, getPortalsPercentages, getPortalsTokens } from '../utils/helpers.js';
+export const getPortalsTradeQuote = async (input, deps) => {
+    const { sellAsset, buyAsset, accountNumber, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit, } = input;
+    const assertion = assertValidTrade({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const { sellChainId } = assertion.unwrap();
+    const addresses = assertQuoteAddresses(input);
+    if (addresses.isErr())
+        return Err(addresses.unwrapErr());
+    const { sendAddress, receiveAddress } = addresses.unwrap();
+    const maybeTokens = getPortalsTokens({ sellAsset, buyAsset });
+    if (maybeTokens.isErr())
+        return Err(maybeTokens.unwrapErr());
+    const { inputToken, outputToken } = maybeTokens.unwrap();
+    const { affiliateBpsPercentage, slippageTolerancePercentage } = getPortalsPercentages({
+        affiliateBps,
+        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+    });
+    const maybePortalsTradeOrderResponse = await fetchPortalsTradeOrder({
+        sender: sendAddress,
+        inputToken,
+        outputToken,
+        inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        slippageTolerancePercentage,
+        partner: getTreasuryAddressFromChainId(sellChainId),
+        feePercentage: affiliateBpsPercentage,
+        validate: true,
+        swapperConfig: deps.config,
+    })
+        .then(res => Ok(res))
+        .catch(async (err) => {
+        if (err instanceof 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 fetchPortalsTradeOrder({
+                sender: sendAddress,
+                inputToken,
+                outputToken,
+                inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                autoSlippage: true,
+                partner: getTreasuryAddressFromChainId(sellChainId),
+                feePercentage: affiliateBpsPercentage,
+                validate: true,
+                swapperConfig: deps.config,
+            })
+                // 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 Err(makeSwapErrorRight({
+                    message: err.message,
+                    details: {
+                        expectedSlippage: portalsExpectedSlippage
+                            ? bn(portalsExpectedSlippage).toFixed(2, BigNumber.ROUND_HALF_UP)
+                            : undefined,
+                    },
+                    cause: err,
+                    code: TradeQuoteError.FinalQuoteMaxSlippageExceeded,
+                }));
+            if (err.message.includes('execution reverted'))
+                return Err(makeSwapErrorRight({
+                    message: err.message,
+                    details: {
+                        expectedSlippage: portalsExpectedSlippage
+                            ? bn(portalsExpectedSlippage).toFixed(2, BigNumber.ROUND_HALF_UP)
+                            : undefined,
+                    },
+                    cause: err,
+                    code: TradeQuoteError.FinalQuoteExecutionReverted,
+                }));
+        }
+        // Validation simulates with the sender's live state, so an unapproved sender fails the
+        // order outright - refetch without validation and estimate under state override instead
+        return fetchPortalsTradeOrder({
             sender: sendAddress,
             inputToken,
             outputToken,
             inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            slippageTolerancePercentage: userSlippageTolerancePercentageDecimalOrDefault,
-            partner: getTreasuryAddressFromChainId(sellAsset.chainId),
+            slippageTolerancePercentage,
+            partner: getTreasuryAddressFromChainId(sellChainId),
             feePercentage: affiliateBpsPercentage,
-            validate: true,
-            swapperConfig,
+            validate: false,
+            swapperConfig: deps.config,
         })
             .then(res => Ok(res))
-            .catch(async (err) => {
-            if (err instanceof 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 fetchPortalsTradeOrder({
-                    sender: sendAddress,
-                    inputToken,
-                    outputToken,
-                    inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                    autoSlippage: true,
-                    partner: 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 Err(makeSwapErrorRight({
-                        message: err.message,
-                        details: {
-                            expectedSlippage: portalsExpectedSlippage
-                                ? bn(portalsExpectedSlippage).toFixed(2, BigNumber.ROUND_HALF_UP)
-                                : undefined,
-                        },
-                        cause: err,
-                        code: TradeQuoteError.FinalQuoteMaxSlippageExceeded,
-                    }));
-                if (err.message.includes('execution reverted'))
-                    return Err(makeSwapErrorRight({
-                        message: err.message,
-                        details: {
-                            expectedSlippage: portalsExpectedSlippage
-                                ? bn(portalsExpectedSlippage).toFixed(2, BigNumber.ROUND_HALF_UP)
-                                : undefined,
-                        },
-                        cause: err,
-                        code: TradeQuoteError.FinalQuoteExecutionReverted,
-                    }));
-            }
-            return Err(makeSwapErrorRight({
-                message: 'failed to get Portals quote',
-                cause: err,
-                code: TradeQuoteError.NetworkFeeEstimationFailed,
-            }));
-        });
-        if (maybePortalsTradeOrderResponse.isErr())
-            return Err(maybePortalsTradeOrderResponse.unwrapErr());
-        const portalsTradeOrderResponse = maybePortalsTradeOrderResponse.unwrap();
-        const { context: { orderId, outputAmount, minOutputAmount, target, feeAmount, gasLimit, feeToken }, tx, } = portalsTradeOrderResponse;
-        const allowanceContract = isCrossChain ? target : 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 = getInputOutputRate({
-            sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-            sellAsset,
-            buyAsset,
-        });
-        const adapter = assertGetEvmChainAdapter(chainId);
-        const { average } = await adapter.getGasFeeData();
-        const networkFeeCryptoBaseUnit = 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: 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 = bnOrZero(buyAmountAfterFeesCryptoBaseUnit)
-            .minus(minOutputAmount)
-            .div(buyAmountAfterFeesCryptoBaseUnit)
-            .toString();
-        // Reverse the buffer to recover the expected output (minOutput / (1 - buffer) = output)
-        const buyAmountBeforeSlippageCryptoBaseUnit = bnOrZero(minOutputAmount)
-            .div(bn(1).minus(actualBufferDecimal))
-            .toFixed(0);
-        const slippageTolerancePercentageDecimal = actualBufferDecimal;
-        const tradeQuote = {
-            id: orderId,
-            quoteOrRate: 'quote',
-            receiveAddress: input.receiveAddress,
-            affiliateBps,
-            rate: inputOutputRate,
-            slippageTolerancePercentageDecimal,
-            swapperName: 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: 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,
-                    },
-                    affiliateFee: buildAffiliateFee({
-                        strategy: 'buy_asset',
-                        affiliateBps,
-                        sellAsset,
-                        buyAsset,
-                        sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-                        isEstimate: true,
-                    }),
-                },
-            ],
-        };
-        return Ok(tradeQuote);
-    }
-    catch (err) {
-        return Err(makeSwapErrorRight({
+            .catch(() => Err(makeSwapErrorRight({
             message: 'failed to get Portals quote',
             cause: err,
             code: TradeQuoteError.NetworkFeeEstimationFailed,
-        }));
-    }
-}
+        })));
+    });
+    if (maybePortalsTradeOrderResponse.isErr())
+        return Err(maybePortalsTradeOrderResponse.unwrapErr());
+    const { context: orderContext, tx } = maybePortalsTradeOrderResponse.unwrap();
+    if (!tx)
+        return Err(makeTradeStepBuildFailedErr('getPortalsTradeQuote'));
+    const maybeContext = getPortalsTradeContext({
+        input,
+        deps,
+        sellChainId,
+        inputToken,
+        orderContext,
+        tx,
+    });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getPortalsStepData({
+        ...stepDataArgs,
+        type: 'quote',
+        input,
+        from: sendAddress,
+    });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { transactionData, networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeQuote = {
+        ...tradeCommon,
+        quoteOrRate: 'quote',
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                transactionData,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
+    };
+    return Ok([tradeQuote]);
+};

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

@@ -1,5 +1,4 @@
-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.js';
-export declare function getPortalsTradeRate(input: GetEvmTradeRateInput, assertGetEvmChainAdapter: (chainId: ChainId) => EvmChainAdapter, swapperConfig: SwapperConfig): Promise<Result<TradeRate, SwapErrorRight>>;
+import type { SwapErrorRight, SwapperDeps, TradeRate } from '../../../types.js';
+import type { PortalsTradeRateInput } from '../types.js';
+export declare const getPortalsTradeRate: (input: PortalsTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;

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

@@ -1,194 +1,79 @@
-import { fromAssetId } from '@shapeshiftoss/caip';
-import { evm } from '@shapeshiftoss/chain-adapters';
-import { bn, bnOrZero, convertBasisPointsToDecimalPercentage } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
-import { v4 as uuid } from 'uuid';
-import { getAddress, zeroAddress } from 'viem';
-import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../index.js';
-import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
-import { simulateWithStateOverrides } from '../../../utils/tenderly/index.js';
-import { getTreasuryAddressFromChainId, isNativeEvmAsset } from '../../utils/helpers/helpers.js';
-import { chainIdToPortalsNetwork } from '../constants.js';
-import { fetchPortalsTradeEstimate, fetchPortalsTradeOrder } from '../utils/fetchPortalsTradeOrder.js';
-import { getPortalsRouterAddressByChainId, isSupportedChainId } from '../utils/helpers.js';
-export async function getPortalsTradeRate(input, assertGetEvmChainAdapter, swapperConfig) {
-    const { sellAsset, buyAsset, accountNumber, affiliateBps, chainId, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, supportsEIP1559, } = input;
-    const sellAssetChainId = sellAsset.chainId;
-    const buyAssetChainId = buyAsset.chainId;
-    if (!isSupportedChainId(sellAssetChainId)) {
-        return Err(makeSwapErrorRight({
-            message: `unsupported chainId`,
-            code: TradeQuoteError.UnsupportedChain,
-            details: { chainId: sellAsset.chainId },
-        }));
-    }
-    if (!isSupportedChainId(buyAssetChainId)) {
-        return Err(makeSwapErrorRight({
-            message: `unsupported chainId`,
-            code: TradeQuoteError.UnsupportedChain,
-            details: { chainId: sellAsset.chainId },
-        }));
-    }
-    if (!isSupportedChainId(chainId)) {
-        return Err(makeSwapErrorRight({
-            message: `unsupported chainId`,
-            code: TradeQuoteError.UnsupportedChain,
-            details: { chainId },
-        }));
-    }
-    const adapter = assertGetEvmChainAdapter(chainId);
-    const isCrossChain = sellAssetChainId !== buyAssetChainId;
-    try {
-        const sellPortalsNetwork = chainIdToPortalsNetwork[sellAssetChainId];
-        const buyPortalsNetwork = chainIdToPortalsNetwork[buyAssetChainId];
-        if (!sellPortalsNetwork) {
-            return Err(makeSwapErrorRight({
-                message: `unsupported ChainId`,
-                code: TradeQuoteError.UnsupportedChain,
-                details: { chainId: sellAssetChainId },
-            }));
-        }
-        if (!buyPortalsNetwork) {
-            return Err(makeSwapErrorRight({
-                message: `unsupported ChainId`,
-                code: TradeQuoteError.UnsupportedChain,
-                details: { chainId: buyAssetChainId },
-            }));
-        }
-        const sellAssetAddress = isNativeEvmAsset(sellAsset.assetId)
-            ? zeroAddress
-            : fromAssetId(sellAsset.assetId).assetReference;
-        const buyAssetAddress = isNativeEvmAsset(buyAsset.assetId)
-            ? zeroAddress
-            : fromAssetId(buyAsset.assetId).assetReference;
-        const inputToken = `${sellPortalsNetwork}:${sellAssetAddress}`;
-        const outputToken = `${buyPortalsNetwork}:${buyAssetAddress}`;
-        const userSlippageTolerancePercentageDecimalOrDefault = input.slippageTolerancePercentageDecimal
-            ? bnOrZero(input.slippageTolerancePercentageDecimal).times(100).toNumber()
-            : bnOrZero(getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Portals))
-                .times(100)
-                .toNumber();
-        // Calculate affiliate fee percentage (e.g., 55 bps = 0.55%)
-        const affiliateBpsPercentage = 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 fetchPortalsTradeOrder({
-            sender: RATE_DUMMY_ADDRESS,
-            inputToken,
-            outputToken,
-            inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            slippageTolerancePercentage: userSlippageTolerancePercentageDecimalOrDefault,
-            partner: 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 = getInputOutputRate({
-            sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-            sellAsset,
-            buyAsset,
-        });
-        const allowanceContract = isCrossChain
-            ? context.target
-            : 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 = bnOrZero(context.outputAmount)
-            .minus(context.minOutputAmount)
-            .div(context.outputAmount)
-            .toString();
-        // Reverse the buffer to recover the expected output (minOutput / (1 - buffer) = output)
-        const buyAmountBeforeSlippageCryptoBaseUnit = bnOrZero(context.minOutputAmount)
-            .div(bn(1).minus(actualBufferDecimal))
-            .toFixed(0);
-        const slippageTolerancePercentageDecimal = actualBufferDecimal;
-        const gasLimit = await (async () => {
-            const tenderlySimulation = await simulateWithStateOverrides({
-                chainId: sellAsset.chainId,
-                from: tx.from,
-                to: tx.to,
-                data: tx.data,
-                value: tx.value,
-                sellAsset,
-                spenderAddress: 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 fetchPortalsTradeEstimate({
-                inputToken,
-                outputToken,
-                inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                slippageTolerancePercentage: userSlippageTolerancePercentageDecimalOrDefault,
-                swapperConfig,
-            });
-            return quoteEstimateResponse.context.gasLimit.toString();
-        })();
-        const { average } = await adapter.getGasFeeData();
-        const networkFeeCryptoBaseUnit = evm.calcNetworkFeeCryptoBaseUnit({
-            ...average,
-            supportsEIP1559: Boolean(supportsEIP1559),
-            gasLimit,
-        });
-        const tradeRate = {
-            id: uuid(),
-            quoteOrRate: 'rate',
-            accountNumber,
-            receiveAddress,
-            affiliateBps,
-            rate: inputOutputRate,
-            slippageTolerancePercentageDecimal,
-            swapperName: 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: SwapperName.Portals,
-                },
-            ],
-        };
-        return Ok(tradeRate);
-    }
-    catch (err) {
-        return Err(makeSwapErrorRight({
-            message: 'failed to get Portals quote',
-            cause: err,
-            code: TradeQuoteError.NetworkFeeEstimationFailed,
-        }));
-    }
-}
+import { makeNetworkFeeEstimationFailedErr, makeTradeStepBuildFailedErr } from '../../../utils/index.js';
+import { getTreasuryAddressFromChainId } from '../../../utils/helpers.js';
+import { PORTALS_RATE_DEFAULT_ADDRESS } from '../constants.js';
+import { fetchPortalsTradeOrder } from '../utils/fetchPortalsTradeOrder.js';
+import { getPortalsStepData } from '../utils/getPortalsStepData.js';
+import { getPortalsTradeContext } from '../utils/getPortalsTradeContext.js';
+import { assertValidTrade, getPortalsPercentages, getPortalsTokens } from '../utils/helpers.js';
+export const getPortalsTradeRate = async (input, deps) => {
+    const { accountNumber, sellAsset, buyAsset, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, } = input;
+    const assertion = assertValidTrade({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const { sellChainId } = assertion.unwrap();
+    const maybeTokens = getPortalsTokens({ sellAsset, buyAsset });
+    if (maybeTokens.isErr())
+        return Err(maybeTokens.unwrapErr());
+    const { inputToken, outputToken } = maybeTokens.unwrap();
+    const { affiliateBpsPercentage, slippageTolerancePercentage } = getPortalsPercentages({
+        affiliateBps,
+        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+    });
+    // Walletless rate: full /portal endpoint (validate off) with a realistic stand-in sender so Portals
+    // prices and estimation can simulate gas
+    const maybeOrder = await fetchPortalsTradeOrder({
+        sender: PORTALS_RATE_DEFAULT_ADDRESS,
+        inputToken,
+        outputToken,
+        inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        slippageTolerancePercentage,
+        partner: getTreasuryAddressFromChainId(sellChainId),
+        feePercentage: affiliateBpsPercentage,
+        validate: false,
+        swapperConfig: deps.config,
+    })
+        .then(res => Ok(res))
+        .catch(err => Err(makeNetworkFeeEstimationFailedErr('getPortalsTradeRate', err)));
+    if (maybeOrder.isErr())
+        return Err(maybeOrder.unwrapErr());
+    const { context: orderContext, tx } = maybeOrder.unwrap();
+    if (!tx)
+        return Err(makeTradeStepBuildFailedErr('getPortalsTradeRate'));
+    const maybeContext = getPortalsTradeContext({
+        input,
+        deps,
+        sellChainId,
+        inputToken,
+        orderContext,
+        tx,
+    });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getPortalsStepData({
+        ...stepDataArgs,
+        type: 'rate',
+        input,
+        inputToken,
+        outputToken,
+        inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        slippageTolerancePercentage,
+    });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeRate = {
+        ...tradeCommon,
+        quoteOrRate: 'rate',
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
+    };
+    return Ok([tradeRate]);
+};

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

@@ -1,2 +1,4 @@
 export * from './constants.js';
 export * from './types.js';
+export { portalsApi } from './endpoints.js';
+export { portalsSwapper } from './PortalsSwapper.js';