@shapeshiftoss/swapper 17.6.3 → 17.6.5

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

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

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

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

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

@@ -0,0 +1,146 @@
+"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 helpers_1 = require("../../utils/helpers/helpers");
+const constants_1 = require("../constants");
+const fetchPortalsTradeOrder_1 = require("../utils/fetchPortalsTradeOrder");
+const helpers_2 = require("../utils/helpers");
+async function getPortalsTradeRate(input, assertGetEvmChainAdapter, swapperConfig) {
+    const { sellAsset, buyAsset, accountNumber, affiliateBps, chainId, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, } = input;
+    const adapter = assertGetEvmChainAdapter(chainId);
+    const sellAssetChainId = sellAsset.chainId;
+    const buyAssetChainId = buyAsset.chainId;
+    if (!(0, helpers_2.isSupportedChainId)(sellAssetChainId)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!(0, helpers_2.isSupportedChainId)(buyAssetChainId)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (sellAssetChainId !== buyAssetChainId) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `cross-chain not supported - both assets must be on chainId ${sellAsset.chainId}`,
+            code: types_1.TradeQuoteError.CrossChainNotSupported,
+            details: { buyAsset, sellAsset },
+        }));
+    }
+    try {
+        if (!(0, helpers_2.isSupportedChainId)(chainId))
+            throw new Error(`Unsupported chainId ${sellAsset.chainId}`);
+        const portalsNetwork = constants_1.chainIdToPortalsNetwork[chainId];
+        if (!portalsNetwork) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: `unsupported ChainId`,
+                code: types_1.TradeQuoteError.UnsupportedChain,
+                details: { chainId: input.chainId },
+            }));
+        }
+        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 = `${portalsNetwork}:${sellAssetAddress}`;
+        const outputToken = `${portalsNetwork}:${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();
+        const quoteEstimateResponse = await (0, fetchPortalsTradeOrder_1.fetchPortalsTradeEstimate)({
+            inputToken,
+            outputToken,
+            inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            slippageTolerancePercentage: userSlippageTolerancePercentageDecimalOrDefault,
+            swapperConfig,
+        });
+        // Estimate has no protocol fees, so after-fees = expected output amount
+        const buyAmountAfterFeesCryptoBaseUnit = quoteEstimateResponse.outputAmount;
+        // Use the quote estimate endpoint to get a quote without a wallet
+        const inputOutputRate = (0, utils_2.getInputOutputRate)({
+            sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const allowanceContract = (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)(quoteEstimateResponse.outputAmount)
+            .minus(quoteEstimateResponse.minOutputAmount)
+            .div(quoteEstimateResponse.outputAmount)
+            .toString();
+        // Reverse the buffer to recover the expected output (minOutput / (1 - buffer) = output)
+        const buyAmountBeforeSlippageCryptoBaseUnit = (0, utils_1.bnOrZero)(quoteEstimateResponse.minOutputAmount)
+            .div((0, utils_1.bn)(1).minus(actualBufferDecimal))
+            .toFixed(0);
+        const slippageTolerancePercentageDecimal = actualBufferDecimal;
+        const gasLimit = quoteEstimateResponse.context.gasLimit;
+        const { average } = await adapter.getGasFeeData();
+        const networkFeeCryptoBaseUnit = chain_adapters_1.evm.calcNetworkFeeCryptoBaseUnit({
+            ...average,
+            supportsEIP1559: Boolean(input.supportsEIP1559),
+            gasLimit: gasLimit.toString(),
+        });
+        const tradeRate = {
+            id: (0, uuid_1.v4)(),
+            quoteOrRate: 'rate',
+            accountNumber,
+            receiveAddress,
+            affiliateBps,
+            rate: inputOutputRate,
+            slippageTolerancePercentageDecimal,
+            swapperName: types_1.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: types_1.SwapperName.Portals,
+                },
+            ],
+        };
+        return (0, monads_1.Ok)(tradeRate);
+    }
+    catch (err) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'failed to get Portals quote',
+            cause: err,
+            code: types_1.TradeQuoteError.NetworkFeeEstimationFailed,
+        }));
+    }
+}
+exports.getPortalsTradeRate = getPortalsTradeRate;

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,76 @@
+import type { Address } from 'viem';
+import type { SwapperConfig } from '../../../types';
+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/cjs/swappers/PortalsSwapper/utils/fetchPortalsTradeOrder.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchPortalsTradeEstimate = exports.fetchPortalsTradeOrder = exports.PortalsError = void 0;
+const axios_1 = __importDefault(require("axios"));
+class PortalsError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PortalsError';
+    }
+}
+exports.PortalsError = PortalsError;
+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_1.default.get(url, { params });
+        return response.data;
+    }
+    catch (error) {
+        if (axios_1.default.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;
+    }
+};
+exports.fetchPortalsTradeOrder = fetchPortalsTradeOrder;
+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_1.default.get(url, { params });
+        return response.data;
+    }
+    catch (error) {
+        if (axios_1.default.isAxiosError(error)) {
+            throw new Error(`Failed to fetch Portals trade estimate: ${error.message}`);
+        }
+        throw error;
+    }
+};
+exports.fetchPortalsTradeEstimate = fetchPortalsTradeEstimate;

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

@@ -0,0 +1,4 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+import type { PortalsSupportedChainId } from '../types';
+export declare const isSupportedChainId: (chainId: ChainId) => chainId is import("@shapeshiftoss/types").KnownChainIds;
+export declare const getPortalsRouterAddressByChainId: (chainId: PortalsSupportedChainId) => string;

package/dist/cjs/swappers/PortalsSwapper/utils/helpers.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPortalsRouterAddressByChainId = exports.isSupportedChainId = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const types_1 = require("../types");
+const isSupportedChainId = (chainId) => {
+    return types_1.PortalsSupportedChainIds.includes(chainId);
+};
+exports.isSupportedChainId = isSupportedChainId;
+const getPortalsRouterAddressByChainId = (chainId) => {
+    switch (chainId) {
+        case caip_1.polygonChainId:
+            return '0xC74063fdb47fe6dCE6d029A489BAb37b167Da57f';
+        case caip_1.ethChainId:
+            return '0xbf5a7f3629fb325e2a8453d595ab103465f75e62';
+        case caip_1.avalancheChainId:
+            return '0xbf5A7F3629fB325E2a8453D595AB103465F75E62';
+        case caip_1.binanceChainId:
+            return '0x34b6a821d2f26c6b7cdb01cd91895170c6574a0d';
+        case caip_1.optimismChainId:
+            return '0x43838f0c0d499f5c3101589f0f452b1fc7515178';
+        case caip_1.arbitrumChainId:
+            return '0x34b6a821d2f26c6b7cdb01cd91895170c6574a0d';
+        case caip_1.baseChainId:
+            return '0xb0324286b3ef7dddc93fb2ff7c8b7b8a3524803c';
+        case caip_1.gnosisChainId:
+            return '0x8e74454b2cf2f6cc2a06083ef122187551cf391c';
+        default:
+            throw new Error(`Router address not found for chainId: ${chainId}`);
+    }
+};
+exports.getPortalsRouterAddressByChainId = getPortalsRouterAddressByChainId;

package/dist/cjs/swappers/RelaySwapper/RelaySwapper.d.ts

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

package/dist/cjs/swappers/RelaySwapper/RelaySwapper.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relaySwapper = void 0;
+const utils_1 = require("../../utils");
+exports.relaySwapper = {
+    executeEvmTransaction: utils_1.executeEvmTransaction,
+    executeSolanaTransaction: utils_1.executeSolanaTransaction,
+    executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
+};

package/dist/cjs/swappers/RelaySwapper/constant.d.ts

@@ -0,0 +1,23 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { TradeQuoteError } from '../../types';
+import { RelayErrorCode } from './utils/types';
+export declare const relaySupportedChainIds: KnownChainIds[];
+export declare const chainIdToRelayChainId: {
+    [x: string]: number;
+};
+export declare enum RelayStatusMessage {
+    WaitingForDeposit = "Waiting for deposit...",
+    DepositDetected = "Deposit detected, processing swap...",
+    Retrying = "Taking a bit longer than usual to find a route, hang tight...",
+    SwapComplete = "Swap complete",
+    SwapFailed = "Swap failed"
+}
+export declare const relayChainIdToChainId: import("lodash").Dictionary<string>;
+export declare const DEFAULT_RELAY_EVM_TOKEN_ADDRESS: "0x0000000000000000000000000000000000000000";
+export declare const RELAY_BTC_TOKEN_ADDRESS = "bc1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqmql8k8";
+export declare const RELAY_SOLANA_TOKEN_ADDRESS = "11111111111111111111111111111111";
+export declare const DEFAULT_RELAY_EVM_USER_ADDRESS = "0x000000000000000000000000000000000000dead";
+export declare const DEFAULT_RELAY_BTC_USER_ADDRESS = "bc1q4vxn43l44h30nkluqfxd9eckf45vr2awz38lwa";
+export declare const DEFAULT_RELAY_SOLANA_USER_ADDRESS = "CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn7X957YwNr";
+export declare const MAXIMUM_SUPPORTED_RELAY_STEPS = 2;
+export declare const relayErrorCodeToTradeQuoteError: Record<RelayErrorCode, TradeQuoteError>;