@shapeshiftoss/swapper 17.6.6 → 17.6.7

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

@@ -0,0 +1,12 @@
+import { ApiError, OneClickService, OpenAPI } from '@defuse-protocol/one-click-sdk-typescript';
+import { ONE_CLICK_BASE_URL } from '../constants.js';
+let isInitialized = false;
+export const initializeOneClickService = (apiKey) => {
+    if (isInitialized)
+        return;
+    OpenAPI.BASE = ONE_CLICK_BASE_URL;
+    OpenAPI.TOKEN = apiKey;
+    isInitialized = true;
+};
+// Re-export the service and types for convenience
+export { ApiError, OneClickService };

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

@@ -0,0 +1,2 @@
+import type { Swapper } from '../../types.js';
+export declare const portalsSwapper: Swapper;

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

@@ -0,0 +1,4 @@
+import { executeEvmTransaction } from '../../utils.js';
+export const portalsSwapper = {
+    executeEvmTransaction,
+};

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

@@ -0,0 +1,2 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export declare const chainIdToPortalsNetwork: Partial<Record<KnownChainIds, string>>;

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

@@ -0,0 +1,11 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export const chainIdToPortalsNetwork = {
+    [KnownChainIds.EthereumMainnet]: 'ethereum',
+    [KnownChainIds.AvalancheMainnet]: 'avalanche',
+    [KnownChainIds.OptimismMainnet]: 'optimism',
+    [KnownChainIds.BnbSmartChainMainnet]: 'bsc',
+    [KnownChainIds.PolygonMainnet]: 'polygon',
+    [KnownChainIds.GnosisMainnet]: 'gnosis',
+    [KnownChainIds.ArbitrumMainnet]: 'arbitrum',
+    [KnownChainIds.BaseMainnet]: 'base',
+};

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

@@ -0,0 +1,2 @@
+import type { SwapperApi } from '../../types.js';
+export declare const portalsApi: SwapperApi;

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

@@ -0,0 +1,50 @@
+import { evm } from '@shapeshiftoss/chain-adapters';
+import BigNumber from 'bignumber.js';
+import { checkEvmSwapStatus, getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { getPortalsTradeQuote } from './getPortalsTradeQuote/getPortalsTradeQuote.js';
+import { getPortalsTradeRate } from './getPortalsTradeRate/getPortalsTradeRate.js';
+export const portalsApi = {
+    getTradeQuote: async (input, { config, assertGetEvmChainAdapter }) => {
+        const tradeQuoteResult = await getPortalsTradeQuote(input, assertGetEvmChainAdapter, config);
+        return tradeQuoteResult.map(tradeQuote => [tradeQuote]);
+    },
+    getTradeRate: async (input, { config, assertGetEvmChainAdapter }) => {
+        const tradeRateResult = await getPortalsTradeRate(input, assertGetEvmChainAdapter, config);
+        return tradeRateResult.map(tradeRate => [tradeRate]);
+    },
+    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = 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 evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
+        return feeData.networkFeeCryptoBaseUnit;
+    },
+    getUnsignedEvmTransaction: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = 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 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.max(feeData.gasLimit, estimatedGas).toFixed(),
+        });
+    },
+    checkTradeStatus: checkEvmSwapStatus,
+};

package/dist/esm/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.js';
+export declare function getPortalsTradeQuote(input: GetEvmTradeQuoteInputBase, assertGetEvmChainAdapter: (chainId: ChainId) => EvmChainAdapter, swapperConfig: SwapperConfig): Promise<Result<TradeQuote, SwapErrorRight>>;

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

@@ -0,0 +1,204 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { evm } from '@shapeshiftoss/chain-adapters';
+import { BigNumber, bn, bnOrZero, convertBasisPointsToDecimalPercentage, } 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 { getTreasuryAddressFromChainId, isNativeEvmAsset } from '../../utils/helpers/helpers.js';
+import { chainIdToPortalsNetwork } from '../constants.js';
+import { fetchPortalsTradeOrder, PortalsError } from '../utils/fetchPortalsTradeOrder.js';
+import { 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: sellAsset.chainId },
+        }));
+    }
+    if (sellAssetChainId !== buyAssetChainId) {
+        return Err(makeSwapErrorRight({
+            message: `cross-chain not supported - both assets must be on chainId ${sellAsset.chainId}`,
+            code: TradeQuoteError.CrossChainNotSupported,
+            details: { buyAsset, sellAsset },
+        }));
+    }
+    // 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 portalsNetwork = chainIdToPortalsNetwork[chainId];
+    if (!portalsNetwork) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported ChainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: input.chainId },
+        }));
+    }
+    const sellAssetAddress = isNativeEvmAsset(sellAsset.assetId)
+        ? zeroAddress
+        : fromAssetId(sellAsset.assetId).assetReference;
+    const buyAssetAddress = isNativeEvmAsset(buyAsset.assetId)
+        ? zeroAddress
+        : fromAssetId(buyAsset.assetId).assetReference;
+    const inputToken = `${portalsNetwork}:${sellAssetAddress}`;
+    const outputToken = `${portalsNetwork}:${buyAssetAddress}`;
+    try {
+        const maybePortalsTradeOrderResponse = await fetchPortalsTradeOrder({
+            sender: sendAddress,
+            inputToken,
+            outputToken,
+            inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            slippageTolerancePercentage: userSlippageTolerancePercentageDecimalOrDefault,
+            partner: getTreasuryAddressFromChainId(sellAsset.chainId),
+            feePercentage: affiliateBpsPercentage,
+            validate: true,
+            swapperConfig,
+        })
+            .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: buyAmountAfterFeesCryptoBaseUnit, minOutputAmount, target: allowanceContract, feeAmount, gasLimit, feeToken, }, tx, } = portalsTradeOrderResponse;
+        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,
+                    // Assume instant execution since this is a same-chain AMM Tx which will happen within the same block
+                    estimatedExecutionTimeMs: 0,
+                    portalsTransactionMetadata: tx,
+                },
+            ],
+        };
+        return Ok(tradeQuote);
+    }
+    catch (err) {
+        return Err(makeSwapErrorRight({
+            message: 'failed to get Portals quote',
+            cause: err,
+            code: TradeQuoteError.NetworkFeeEstimationFailed,
+        }));
+    }
+}

package/dist/esm/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.js';
+export declare function getPortalsTradeRate(input: GetEvmTradeRateInput, assertGetEvmChainAdapter: (chainId: ChainId) => EvmChainAdapter, swapperConfig: SwapperConfig): Promise<Result<TradeRate, SwapErrorRight>>;

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

@@ -0,0 +1,185 @@
+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 adapter = assertGetEvmChainAdapter(chainId);
+    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 (sellAssetChainId !== buyAssetChainId) {
+        return Err(makeSwapErrorRight({
+            message: `cross-chain not supported - both assets must be on chainId ${sellAsset.chainId}`,
+            code: TradeQuoteError.CrossChainNotSupported,
+            details: { buyAsset, sellAsset },
+        }));
+    }
+    try {
+        if (!isSupportedChainId(chainId))
+            throw new Error(`Unsupported chainId ${sellAsset.chainId}`);
+        const portalsNetwork = chainIdToPortalsNetwork[chainId];
+        if (!portalsNetwork) {
+            return Err(makeSwapErrorRight({
+                message: `unsupported ChainId`,
+                code: TradeQuoteError.UnsupportedChain,
+                details: { chainId: input.chainId },
+            }));
+        }
+        const sellAssetAddress = isNativeEvmAsset(sellAsset.assetId)
+            ? zeroAddress
+            : fromAssetId(sellAsset.assetId).assetReference;
+        const buyAssetAddress = isNativeEvmAsset(buyAsset.assetId)
+            ? zeroAddress
+            : fromAssetId(buyAsset.assetId).assetReference;
+        const inputToken = `${portalsNetwork}:${sellAssetAddress}`;
+        const outputToken = `${portalsNetwork}:${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;
+        // Use outputAmount from context, not estimate
+        const buyAmountAfterFeesCryptoBaseUnit = context.outputAmount;
+        const inputOutputRate = getInputOutputRate({
+            sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const allowanceContract = 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: [
+                {
+                    // Assume instant execution since this is a same-chain AMM Tx which will happen within the same block
+                    estimatedExecutionTimeMs: 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,
+        }));
+    }
+}

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

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

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

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

package/dist/esm/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/esm/swappers/PortalsSwapper/types.js

@@ -0,0 +1,12 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+// https://api.portals.fi/v1/networks
+export const PortalsSupportedChainIds = [
+    KnownChainIds.EthereumMainnet,
+    KnownChainIds.ArbitrumMainnet,
+    KnownChainIds.AvalancheMainnet,
+    KnownChainIds.PolygonMainnet,
+    KnownChainIds.BnbSmartChainMainnet,
+    KnownChainIds.OptimismMainnet,
+    KnownChainIds.GnosisMainnet,
+    KnownChainIds.BaseMainnet,
+];

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

@@ -0,0 +1,76 @@
+import type { Address } from 'viem';
+import type { SwapperConfig } from '../../../types.js';
+type PortalsTradeOrderParams = {
+    sender: string;
+    inputToken: string;
+    inputAmount: string;
+    outputToken: string;
+    partner: string;
+    feePercentage?: number;
+    validate: boolean;
+    swapperConfig: SwapperConfig;
+} & ({
+    slippageTolerancePercentage: number;
+    autoSlippage?: never;
+} | {
+    slippageTolerancePercentage?: never;
+    autoSlippage: true;
+});
+type PortalsTradeOrderEstimateParams = Omit<PortalsTradeOrderParams, 'partner' | 'validate' | 'sender'>;
+type PortalsTradeOrderResponse = {
+    context: {
+        orderId: string;
+        inputToken: string;
+        inputAmount: string;
+        inputAmountUsd: number;
+        outputToken: string;
+        outputAmount: string;
+        outputAmountUsd: number;
+        minOutputAmount: string;
+        minOutputAmountUsd: number;
+        slippageTolerancePercentage: number;
+        target: string;
+        partner: string;
+        sender: string;
+        recipient: string;
+        value: string;
+        route: string[];
+        routeHash: string;
+        steps: string[];
+        gasLimit?: string;
+        feeToken?: string;
+        feeAmount?: string;
+        feeAmountUsd?: number;
+    };
+    tx?: {
+        to: Address;
+        from: Address;
+        data: string;
+        value: string;
+        gasLimit: string;
+    };
+};
+type PortalsTradeOrderEstimateResponse = {
+    outputAmount: string;
+    minOutputAmount: string;
+    outputToken: string;
+    outputTokenDecimals: number;
+    context: {
+        slippageTolerancePercentage: number;
+        inputAmount: string;
+        inputAmountUsd: number;
+        inputToken: string;
+        outputToken: string;
+        outputAmount: string;
+        outputAmountUsd: number;
+        minOutputAmountUsd: number;
+        gasLimit: number;
+        sender?: string;
+    };
+};
+export declare class PortalsError extends Error {
+    constructor(message: string);
+}
+export declare const fetchPortalsTradeOrder: ({ sender, inputToken, inputAmount, outputToken, slippageTolerancePercentage, autoSlippage, partner, feePercentage, validate, swapperConfig, }: PortalsTradeOrderParams) => Promise<PortalsTradeOrderResponse>;
+export declare const fetchPortalsTradeEstimate: ({ inputToken, inputAmount, outputToken, slippageTolerancePercentage, swapperConfig, }: PortalsTradeOrderEstimateParams) => Promise<PortalsTradeOrderEstimateResponse>;
+export {};

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

@@ -0,0 +1,59 @@
+import axios from 'axios';
+export class PortalsError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PortalsError';
+    }
+}
+export const fetchPortalsTradeOrder = async ({ sender, inputToken, inputAmount, outputToken, slippageTolerancePercentage, autoSlippage, partner, feePercentage, validate, swapperConfig, }) => {
+    const url = `${swapperConfig.VITE_PORTALS_BASE_URL}/v2/portal`;
+    const params = new URLSearchParams({
+        partner,
+        ...(sender ? { sender } : {}),
+        inputToken,
+        inputAmount,
+        outputToken,
+        validate: validate.toString(),
+    });
+    if (!autoSlippage) {
+        params.append('slippageTolerancePercentage', slippageTolerancePercentage.toFixed(2)); // Portals API expects a string with at most 2 decimal places
+    }
+    if (feePercentage) {
+        params.append('feePercentage', feePercentage.toString());
+    }
+    try {
+        const response = await axios.get(url, { params });
+        return response.data;
+    }
+    catch (error) {
+        if (axios.isAxiosError(error)) {
+            const message = error.response?.data?.message;
+            if (message) {
+                throw new PortalsError(message);
+            }
+            throw new Error(`Failed to fetch Portals trade order: ${error.message}`);
+        }
+        throw error;
+    }
+};
+export const fetchPortalsTradeEstimate = async ({ inputToken, inputAmount, outputToken, slippageTolerancePercentage, swapperConfig, }) => {
+    const url = `${swapperConfig.VITE_PORTALS_BASE_URL}/v2/portal/estimate`;
+    const params = new URLSearchParams({
+        inputToken,
+        inputAmount,
+        outputToken,
+    });
+    if (slippageTolerancePercentage !== undefined) {
+        params.append('slippageTolerancePercentage', slippageTolerancePercentage.toFixed(2)); // Portals API expects a string with at most 2 decimal places
+    }
+    try {
+        const response = await axios.get(url, { params });
+        return response.data;
+    }
+    catch (error) {
+        if (axios.isAxiosError(error)) {
+            throw new Error(`Failed to fetch Portals trade estimate: ${error.message}`);
+        }
+        throw error;
+    }
+};