@shapeshiftoss/swapper 17.8.0 → 19.0.0

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

@@ -1,198 +1,83 @@
 "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 utils_1 = require("../../../utils");
+const helpers_1 = require("../../../utils/helpers");
 const constants_1 = require("../constants");
 const fetchPortalsTradeOrder_1 = require("../utils/fetchPortalsTradeOrder");
+const getPortalsStepData_1 = require("../utils/getPortalsStepData");
+const getPortalsTradeContext_1 = require("../utils/getPortalsTradeContext");
 const helpers_2 = require("../utils/helpers");
-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 (!(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 },
-        }));
-    }
-    if (!(0, helpers_2.isSupportedChainId)(chainId)) {
-        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
-            message: `unsupported chainId`,
-            code: types_1.TradeQuoteError.UnsupportedChain,
-            details: { chainId },
-        }));
-    }
-    const adapter = assertGetEvmChainAdapter(chainId);
-    const isCrossChain = sellAssetChainId !== buyAssetChainId;
-    try {
-        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,
-        }));
-    }
-}
+const getPortalsTradeRate = async (input, deps) => {
+    const { accountNumber, sellAsset, buyAsset, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, } = input;
+    const assertion = (0, helpers_2.assertValidTrade)({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return (0, monads_1.Err)(assertion.unwrapErr());
+    const { sellChainId } = assertion.unwrap();
+    const maybeTokens = (0, helpers_2.getPortalsTokens)({ sellAsset, buyAsset });
+    if (maybeTokens.isErr())
+        return (0, monads_1.Err)(maybeTokens.unwrapErr());
+    const { inputToken, outputToken } = maybeTokens.unwrap();
+    const { affiliateBpsPercentage, slippageTolerancePercentage } = (0, helpers_2.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 (0, fetchPortalsTradeOrder_1.fetchPortalsTradeOrder)({
+        sender: constants_1.PORTALS_RATE_DEFAULT_ADDRESS,
+        inputToken,
+        outputToken,
+        inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        slippageTolerancePercentage,
+        partner: (0, helpers_1.getTreasuryAddressFromChainId)(sellChainId),
+        feePercentage: affiliateBpsPercentage,
+        validate: false,
+        swapperConfig: deps.config,
+    })
+        .then(res => (0, monads_1.Ok)(res))
+        .catch(err => (0, monads_1.Err)((0, utils_1.makeNetworkFeeEstimationFailedErr)('getPortalsTradeRate', err)));
+    if (maybeOrder.isErr())
+        return (0, monads_1.Err)(maybeOrder.unwrapErr());
+    const { context: orderContext, tx } = maybeOrder.unwrap();
+    if (!tx)
+        return (0, monads_1.Err)((0, utils_1.makeTradeStepBuildFailedErr)('getPortalsTradeRate'));
+    const maybeContext = (0, getPortalsTradeContext_1.getPortalsTradeContext)({
+        input,
+        deps,
+        sellChainId,
+        inputToken,
+        orderContext,
+        tx,
+    });
+    if (maybeContext.isErr())
+        return (0, monads_1.Err)(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await (0, getPortalsStepData_1.getPortalsStepData)({
+        ...stepDataArgs,
+        type: 'rate',
+        input,
+        inputToken,
+        outputToken,
+        inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        slippageTolerancePercentage,
+    });
+    if (maybeStepData.isErr())
+        return (0, monads_1.Err)(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeRate = {
+        ...tradeCommon,
+        quoteOrRate: 'rate',
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
+    };
+    return (0, monads_1.Ok)([tradeRate]);
+};
 exports.getPortalsTradeRate = getPortalsTradeRate;

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

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

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

@@ -14,5 +14,10 @@ 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 });
+exports.portalsSwapper = exports.portalsApi = void 0;
 __exportStar(require("./constants"), exports);
 __exportStar(require("./types"), exports);
+var endpoints_1 = require("./endpoints");
+Object.defineProperty(exports, "portalsApi", { enumerable: true, get: function () { return endpoints_1.portalsApi; } });
+var PortalsSwapper_1 = require("./PortalsSwapper");
+Object.defineProperty(exports, "portalsSwapper", { enumerable: true, get: function () { return PortalsSwapper_1.portalsSwapper; } });

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

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

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

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

package/dist/cjs/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/cjs/swappers/PortalsSwapper/utils/getPortalsStepData.d.ts

@@ -0,0 +1,27 @@
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types';
+import type { PortalsTx } from './fetchPortalsTradeOrder';
+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/cjs/swappers/PortalsSwapper/utils/getPortalsStepData.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPortalsStepData = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const monads_1 = require("@sniptt/monads");
+const utils_1 = require("../../../utils");
+const evm_1 = require("../../../utils/evm");
+const fetchPortalsTradeOrder_1 = require("./fetchPortalsTradeOrder");
+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 (0, evm_1.estimateGasWithStateOverride)({
+                        sellAsset,
+                        sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                        from: tx.from,
+                        spenderAddress,
+                        to: tx.to,
+                        data: tx.data,
+                        value: tx.value,
+                    });
+                    return gasLimit;
+                }
+                catch {
+                    const quoteEstimateResponse = await (0, fetchPortalsTradeOrder_1.fetchPortalsTradeEstimate)({
+                        inputToken: args.inputToken,
+                        outputToken: args.outputToken,
+                        inputAmount: args.inputAmount,
+                        slippageTolerancePercentage: args.slippageTolerancePercentage,
+                        swapperConfig: deps.config,
+                    });
+                    return quoteEstimateResponse.context.gasLimit.toString();
+                }
+            })();
+            const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+                adapter,
+                supportsEIP1559,
+                gasLimit,
+            });
+            const stepData = { networkFeeCryptoBaseUnit };
+            return (0, monads_1.Ok)(stepData);
+        }
+        catch (error) {
+            return (0, monads_1.Err)((0, utils_1.makeNetworkFeeEstimationFailedErr)('getPortalsStepData', error));
+        }
+    }
+    const transactionData = {
+        type: 'evm',
+        chainId: Number((0, caip_1.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 (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+            adapter,
+            transactionData,
+            from: args.from,
+            supportsEIP1559,
+            stateOverride: {
+                sellAsset,
+                sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                spenderAddress,
+            },
+        });
+        const stepData = { transactionData, networkFeeCryptoBaseUnit };
+        return (0, monads_1.Ok)(stepData);
+    }
+    catch (error) {
+        return (0, monads_1.Err)((0, utils_1.makeNetworkFeeEstimationFailedErr)('getPortalsStepData', error));
+    }
+}
+exports.getPortalsStepData = getPortalsStepData;

package/dist/cjs/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';
+import type { PortalsSupportedChainId, PortalsTradeQuoteInput, PortalsTradeRateInput } from '../types';
+import type { PortalsTradeOrderResponse, PortalsTx } from './fetchPortalsTradeOrder';
+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/cjs/swappers/PortalsSwapper/utils/getPortalsTradeContext.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPortalsTradeContext = void 0;
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const affiliateFee_1 = require("../../../utils/affiliateFee");
+const helpers_1 = require("./helpers");
+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 = (0, utils_2.getInputOutputRate)({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    // Cross-chain approves the route target; same-chain approves the Portals router
+    const allowanceContract = isCrossChain ? target : (0, helpers_1.getPortalsRouterAddressByChainId)(sellChainId);
+    if (allowanceContract === undefined) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `no Portals router for chainId ${sellChainId}`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellChainId },
+        }));
+    }
+    // Portals reports the slippage we requested, not what it applied — recover the actual buffer 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 buyAmountBeforeFeesCryptoBaseUnit = (0, utils_1.bnOrZero)(minOutputAmount)
+        .div((0, utils_1.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 (0, monads_1.Ok)({
+        tradeCommon: {
+            id: orderId,
+            rate,
+            swapperName: types_1.SwapperName.Portals,
+            affiliateBps,
+            slippageTolerancePercentageDecimal: actualBufferDecimal,
+        },
+        stepCommon: {
+            estimatedExecutionTimeMs: isCrossChain ? 300000 : 0,
+            allowanceContract,
+            rate,
+            buyAsset,
+            sellAsset,
+            buyAmountBeforeFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            source: types_1.SwapperName.Portals,
+            affiliateFee: (0, affiliateFee_1.buildAffiliateFee)({
+                strategy: 'buy_asset',
+                affiliateBps,
+                sellAsset,
+                buyAsset,
+                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                isEstimate: true,
+            }),
+        },
+        protocolFees,
+        stepDataArgs: { deps, sellAsset, spenderAddress: allowanceContract, tx },
+    });
+};
+exports.getPortalsTradeContext = getPortalsTradeContext;

package/dist/cjs/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';
 import type { PortalsSupportedChainId } from '../types';
-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;