@shapeshiftoss/swapper 17.8.0 → 19.0.0

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';

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

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

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

@@ -1,3 +1,6 @@
 import { KnownChainIds } from '@shapeshiftoss/types';
+import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput } from '../../types.js';
+export type PortalsTradeQuoteInput = GetEvmTradeQuoteInput;
+export type PortalsTradeRateInput = GetEvmTradeRateInput;
 export declare const PortalsSupportedChainIds: KnownChainIds[];
 export type PortalsSupportedChainId = (typeof PortalsSupportedChainIds)[number];

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

@@ -7,7 +7,8 @@ export const PortalsSupportedChainIds = [
     KnownChainIds.PolygonMainnet,
     KnownChainIds.BnbSmartChainMainnet,
     KnownChainIds.OptimismMainnet,
-    KnownChainIds.GnosisMainnet,
     KnownChainIds.BaseMainnet,
     KnownChainIds.HyperEvmMainnet,
+    KnownChainIds.SonicMainnet,
+    KnownChainIds.PlasmaMainnet,
 ];

package/dist/esm/swappers/PortalsSwapper/utils/fetchAxelarscanStatus.js

@@ -1,5 +1,5 @@
 import { Err, Ok } from '@sniptt/monads';
-import { makeSwapErrorRight } from '../../../utils.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
 export const fetchAxelarscanBridgeStatus = async (sourceTxHash) => {
     try {
         const response = await fetch(`https://api.axelarscan.io/gmp/searchGMP?txHash=${sourceTxHash}`);

package/dist/esm/swappers/PortalsSwapper/utils/fetchPortalsTradeOrder.d.ts

@@ -17,7 +17,14 @@ type PortalsTradeOrderParams = {
     autoSlippage: true;
 });
 type PortalsTradeOrderEstimateParams = Omit<PortalsTradeOrderParams, 'partner' | 'validate' | 'sender'>;
-type PortalsTradeOrderResponse = {
+export type PortalsTx = {
+    to: Address;
+    from: Address;
+    data: string;
+    value: string;
+    gasLimit?: string;
+};
+export type PortalsTradeOrderResponse = {
     context: {
         orderId: string;
         inputToken: string;
@@ -43,13 +50,7 @@ type PortalsTradeOrderResponse = {
         feeAmount?: string;
         feeAmountUsd?: number;
     };
-    tx?: {
-        to: Address;
-        from: Address;
-        data: string;
-        value: string;
-        gasLimit: string;
-    };
+    tx?: PortalsTx;
 };
 type PortalsTradeOrderEstimateResponse = {
     outputAmount: string;

package/dist/esm/swappers/PortalsSwapper/utils/fetchSquidStatus.js

@@ -1,6 +1,6 @@
 import { fromChainId } from '@shapeshiftoss/caip';
 import { Err, Ok } from '@sniptt/monads';
-import { makeSwapErrorRight } from '../../../utils.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
 export const fetchSquidBridgeStatus = async (sourceTxHash, sourceChainId, destinationChainId) => {
     try {
         const fromChain = fromChainId(sourceChainId).chainReference;

package/dist/esm/swappers/PortalsSwapper/utils/getPortalsStepData.d.ts

@@ -0,0 +1,27 @@
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.js';
+import type { PortalsTx } from './fetchPortalsTradeOrder.js';
+type BaseArgs = {
+    tx: PortalsTx;
+    spenderAddress: string;
+};
+export type GetPortalsStepDataArgs = StepDataArgs<BaseArgs, {
+    inputToken: string;
+    outputToken: string;
+    inputAmount: string;
+    slippageTolerancePercentage: number;
+}>;
+type PortalsRateStepData = {
+    networkFeeCryptoBaseUnit: string;
+};
+type PortalsQuoteStepData = {
+    transactionData: TxBuildData;
+    networkFeeCryptoBaseUnit: string;
+};
+export declare function getPortalsStepData(args: Extract<GetPortalsStepDataArgs, {
+    type: 'rate';
+}>): Promise<Result<PortalsRateStepData, SwapErrorRight>>;
+export declare function getPortalsStepData(args: Extract<GetPortalsStepDataArgs, {
+    type: 'quote';
+}>): Promise<Result<PortalsQuoteStepData, SwapErrorRight>>;
+export {};

package/dist/esm/swappers/PortalsSwapper/utils/getPortalsStepData.js

@@ -0,0 +1,78 @@
+import { fromChainId } from '@shapeshiftoss/caip';
+import { Err, Ok } from '@sniptt/monads';
+import { makeNetworkFeeEstimationFailedErr } from '../../../utils/index.js';
+import { estimateGasWithStateOverride, getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
+import { fetchPortalsTradeEstimate } from './fetchPortalsTradeOrder.js';
+export async function getPortalsStepData(args) {
+    const { tx, sellAsset, spenderAddress, input, deps } = args;
+    const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+    const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
+    if (args.type === 'rate') {
+        try {
+            // No placeholder estimation for provider built routes - overridden estimation (approval
+            // state need not exist yet) with the Portals estimate endpoint as fallback
+            const gasLimit = await (async () => {
+                try {
+                    const gasLimit = await estimateGasWithStateOverride({
+                        sellAsset,
+                        sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                        from: tx.from,
+                        spenderAddress,
+                        to: tx.to,
+                        data: tx.data,
+                        value: tx.value,
+                    });
+                    return gasLimit;
+                }
+                catch {
+                    const quoteEstimateResponse = await fetchPortalsTradeEstimate({
+                        inputToken: args.inputToken,
+                        outputToken: args.outputToken,
+                        inputAmount: args.inputAmount,
+                        slippageTolerancePercentage: args.slippageTolerancePercentage,
+                        swapperConfig: deps.config,
+                    });
+                    return quoteEstimateResponse.context.gasLimit.toString();
+                }
+            })();
+            const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+                adapter,
+                supportsEIP1559,
+                gasLimit,
+            });
+            const stepData = { networkFeeCryptoBaseUnit };
+            return Ok(stepData);
+        }
+        catch (error) {
+            return Err(makeNetworkFeeEstimationFailedErr('getPortalsStepData', error));
+        }
+    }
+    const transactionData = {
+        type: 'evm',
+        chainId: Number(fromChainId(sellAsset.chainId).chainReference),
+        to: tx.to,
+        data: tx.data,
+        value: tx.value,
+        // Portals simulate and pad their gas limit when the order was validated, so no additional
+        // buffer - an unvalidated order carries no gas limit and estimates below instead
+        gasLimit: tx.gasLimit,
+    };
+    try {
+        const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+            adapter,
+            transactionData,
+            from: args.from,
+            supportsEIP1559,
+            stateOverride: {
+                sellAsset,
+                sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                spenderAddress,
+            },
+        });
+        const stepData = { transactionData, networkFeeCryptoBaseUnit };
+        return Ok(stepData);
+    }
+    catch (error) {
+        return Err(makeNetworkFeeEstimationFailedErr('getPortalsStepData', error));
+    }
+}

package/dist/esm/swappers/PortalsSwapper/utils/getPortalsTradeContext.d.ts

@@ -0,0 +1,25 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types.js';
+import type { PortalsSupportedChainId, PortalsTradeQuoteInput, PortalsTradeRateInput } from '../types.js';
+import type { PortalsTradeOrderResponse, PortalsTx } from './fetchPortalsTradeOrder.js';
+type PortalsTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    stepDataArgs: {
+        deps: SwapperDeps;
+        sellAsset: Asset;
+        spenderAddress: string;
+        tx: PortalsTx;
+    };
+};
+export declare const getPortalsTradeContext: ({ input, deps, sellChainId, inputToken, orderContext, tx, }: {
+    input: PortalsTradeQuoteInput | PortalsTradeRateInput;
+    deps: SwapperDeps;
+    sellChainId: PortalsSupportedChainId;
+    inputToken: string;
+    orderContext: PortalsTradeOrderResponse['context'];
+    tx: PortalsTx;
+}) => Result<PortalsTradeContext, SwapErrorRight>;
+export {};

package/dist/esm/swappers/PortalsSwapper/utils/getPortalsTradeContext.js

@@ -0,0 +1,79 @@
+import { bn, bnOrZero } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils/index.js';
+import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
+import { getPortalsRouterAddressByChainId } from './helpers.js';
+export const getPortalsTradeContext = ({ input, deps, sellChainId, inputToken, orderContext, tx, }) => {
+    const { sellAsset, buyAsset, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
+    const { orderId, outputAmount, minOutputAmount, target, feeAmount, feeToken } = orderContext;
+    const isCrossChain = sellAsset.chainId !== buyAsset.chainId;
+    const buyAmountAfterFeesCryptoBaseUnit = isCrossChain ? minOutputAmount : outputAmount;
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    // Cross-chain approves the route target; same-chain approves the Portals router
+    const allowanceContract = isCrossChain ? target : getPortalsRouterAddressByChainId(sellChainId);
+    if (allowanceContract === undefined) {
+        return Err(makeSwapErrorRight({
+            message: `no Portals router for chainId ${sellChainId}`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellChainId },
+        }));
+    }
+    // Portals reports the slippage we requested, not what it applied — recover the actual buffer 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 buyAmountBeforeFeesCryptoBaseUnit = bnOrZero(minOutputAmount)
+        .div(bn(1).minus(actualBufferDecimal))
+        .toFixed(0);
+    const protocolFeeAsset = feeToken === inputToken ? sellAsset : buyAsset;
+    const protocolFees = (() => {
+        if (!feeToken || !feeAmount)
+            return;
+        return {
+            [protocolFeeAsset.assetId]: {
+                amountCryptoBaseUnit: feeAmount,
+                asset: protocolFeeAsset,
+                requiresBalance: false,
+            },
+        };
+    })();
+    return Ok({
+        tradeCommon: {
+            id: orderId,
+            rate,
+            swapperName: SwapperName.Portals,
+            affiliateBps,
+            slippageTolerancePercentageDecimal: actualBufferDecimal,
+        },
+        stepCommon: {
+            estimatedExecutionTimeMs: isCrossChain ? 300000 : 0,
+            allowanceContract,
+            rate,
+            buyAsset,
+            sellAsset,
+            buyAmountBeforeFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            source: SwapperName.Portals,
+            affiliateFee: buildAffiliateFee({
+                strategy: 'buy_asset',
+                affiliateBps,
+                sellAsset,
+                buyAsset,
+                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                isEstimate: true,
+            }),
+        },
+        protocolFees,
+        stepDataArgs: { deps, sellAsset, spenderAddress: allowanceContract, tx },
+    });
+};

package/dist/esm/swappers/PortalsSwapper/utils/helpers.d.ts

@@ -1,4 +1,28 @@
 import type { ChainId } from '@shapeshiftoss/caip';
+import type { Asset, KnownChainIds } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types.js';
 import type { PortalsSupportedChainId } from '../types.js';
-export declare const isSupportedChainId: (chainId: ChainId) => chainId is import("@shapeshiftoss/types").KnownChainIds;
-export declare const getPortalsRouterAddressByChainId: (chainId: PortalsSupportedChainId) => string;
+export declare const isSupportedChainId: (chainId: ChainId) => chainId is KnownChainIds;
+export declare const assertValidTrade: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Result<{
+    sellChainId: PortalsSupportedChainId;
+    buyChainId: PortalsSupportedChainId;
+}, SwapErrorRight>;
+export declare const getPortalsTokens: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Result<{
+    inputToken: string;
+    outputToken: string;
+}, SwapErrorRight>;
+export declare const getPortalsPercentages: ({ affiliateBps, slippageTolerancePercentageDecimal, }: {
+    affiliateBps: string;
+    slippageTolerancePercentageDecimal: string | undefined;
+}) => {
+    affiliateBpsPercentage: number;
+    slippageTolerancePercentage: number;
+};
+export declare const getPortalsRouterAddressByChainId: (chainId: PortalsSupportedChainId) => string | undefined;