@shapeshiftoss/swapper 17.6.6 → 17.6.7

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNearIntentsStatusMessage = exports.mapNearIntentsStatus = exports.assetToNearIntentsAsset = exports.getNearIntentsAsset = exports.calculateAccountCreationCosts = void 0;
+const token_1 = require("@coral-xyz/anchor/dist/cjs/utils/token");
+const caip_1 = require("@shapeshiftoss/caip");
+const unchained_client_1 = require("@shapeshiftoss/unchained-client");
+const utils_1 = require("@shapeshiftoss/utils");
+const viem_1 = require("viem");
+const types_1 = require("../../types");
+const oneClickService_1 = require("../oneClickService");
+const ATA_RENT_LAMPORTS = 2040000;
+const calculateAccountCreationCosts = (instructions) => {
+    let totalCost = (0, utils_1.bnOrZero)(0);
+    for (const ix of instructions) {
+        if (ix.programId.toString() === token_1.ASSOCIATED_PROGRAM_ID.toString()) {
+            totalCost = totalCost.plus(ATA_RENT_LAMPORTS);
+        }
+    }
+    return totalCost.toString();
+};
+exports.calculateAccountCreationCosts = calculateAccountCreationCosts;
+const getNearIntentsAsset = ({ nearNetwork, contractAddress, }) => {
+    // Native EVM assets: "nep141:eth.omft.near"
+    if (contractAddress === viem_1.zeroAddress) {
+        return `nep141:${nearNetwork}.omft.near`;
+    }
+    // ERC20 tokens: "nep141:eth-0x{address}.omft.near"
+    return `nep141:${nearNetwork}-${contractAddress.toLowerCase()}.omft.near`;
+};
+exports.getNearIntentsAsset = getNearIntentsAsset;
+const NEP245_CHAINS = ['bsc', 'pol', 'avax', 'op', 'tron'];
+const TOKEN_LOOKUP_CHAINS = ['sui'];
+const assetToNearIntentsAsset = async (asset) => {
+    const nearNetwork = types_1.chainIdToNearIntentsChain[asset.chainId];
+    if (!nearNetwork)
+        return null;
+    // NEP-245 chains (BSC, Polygon, Avalanche, Optimism, TRON, SUI) and Solana require token lookup
+    // Asset IDs use hashed format that can't be generated from contract addresses
+    const requiresLookup = NEP245_CHAINS.includes(nearNetwork) ||
+        TOKEN_LOOKUP_CHAINS.includes(nearNetwork) ||
+        asset.chainId === caip_1.solanaChainId ||
+        asset.chainId === caip_1.suiChainId;
+    if (requiresLookup) {
+        const tokens = await oneClickService_1.OneClickService.getTokens();
+        const { assetNamespace, assetReference } = (0, caip_1.fromAssetId)(asset.assetId);
+        const isNativeAsset = assetNamespace === 'slip44';
+        const contractAddress = !isNativeAsset ? assetReference.toLowerCase() : null;
+        const match = tokens.find((t) => {
+            if (t.blockchain !== nearNetwork)
+                return false;
+            return contractAddress
+                ? t.contractAddress?.toLowerCase() === contractAddress
+                : !t.contractAddress;
+        });
+        if (!match) {
+            return null;
+        }
+        return match.assetId;
+    }
+    // NEP-141 chains (ETH, ARB, BASE, GNOSIS, BTC, DOGE): use predictable format
+    const contractAddress = (0, utils_1.isToken)(asset.assetId)
+        ? (0, caip_1.fromAssetId)(asset.assetId).assetReference
+        : viem_1.zeroAddress;
+    return (0, exports.getNearIntentsAsset)({ nearNetwork, contractAddress });
+};
+exports.assetToNearIntentsAsset = assetToNearIntentsAsset;
+const mapNearIntentsStatus = (status) => {
+    switch (status) {
+        case 'PENDING_DEPOSIT':
+        case 'KNOWN_DEPOSIT_TX':
+        case 'PROCESSING':
+            return unchained_client_1.TxStatus.Pending;
+        case 'SUCCESS':
+            return unchained_client_1.TxStatus.Confirmed;
+        case 'INCOMPLETE_DEPOSIT':
+        case 'REFUNDED':
+        case 'FAILED':
+            return unchained_client_1.TxStatus.Failed;
+        default:
+            return unchained_client_1.TxStatus.Unknown;
+    }
+};
+exports.mapNearIntentsStatus = mapNearIntentsStatus;
+const getNearIntentsStatusMessage = (status) => {
+    switch (status) {
+        case 'PENDING_DEPOSIT':
+            return 'Waiting for deposit...';
+        case 'KNOWN_DEPOSIT_TX':
+            return 'Deposit detected, waiting for confirmation...';
+        case 'PROCESSING':
+            return 'Processing swap...';
+        case 'SUCCESS':
+            return undefined;
+        case 'INCOMPLETE_DEPOSIT':
+            return 'Insufficient deposit amount';
+        case 'REFUNDED':
+            return 'Swap failed, funds refunded';
+        case 'FAILED':
+            return 'Swap failed';
+        default:
+            return 'Unknown status';
+    }
+};
+exports.getNearIntentsStatusMessage = getNearIntentsStatusMessage;

package/dist/cjs/swappers/NearIntentsSwapper/utils/oneClickService.d.ts

@@ -0,0 +1,3 @@
+import { ApiError, OneClickService } from '@defuse-protocol/one-click-sdk-typescript';
+export declare const initializeOneClickService: (apiKey: string) => void;
+export { ApiError, OneClickService };

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneClickService = exports.ApiError = exports.initializeOneClickService = void 0;
+const one_click_sdk_typescript_1 = require("@defuse-protocol/one-click-sdk-typescript");
+Object.defineProperty(exports, "ApiError", { enumerable: true, get: function () { return one_click_sdk_typescript_1.ApiError; } });
+Object.defineProperty(exports, "OneClickService", { enumerable: true, get: function () { return one_click_sdk_typescript_1.OneClickService; } });
+const constants_1 = require("../constants");
+let isInitialized = false;
+const initializeOneClickService = (apiKey) => {
+    if (isInitialized)
+        return;
+    one_click_sdk_typescript_1.OpenAPI.BASE = constants_1.ONE_CLICK_BASE_URL;
+    one_click_sdk_typescript_1.OpenAPI.TOKEN = apiKey;
+    isInitialized = true;
+};
+exports.initializeOneClickService = initializeOneClickService;

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

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

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.portalsSwapper = void 0;
+const utils_1 = require("../../utils");
+exports.portalsSwapper = {
+    executeEvmTransaction: utils_1.executeEvmTransaction,
+};

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

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

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chainIdToPortalsNetwork = void 0;
+const types_1 = require("@shapeshiftoss/types");
+exports.chainIdToPortalsNetwork = {
+    [types_1.KnownChainIds.EthereumMainnet]: 'ethereum',
+    [types_1.KnownChainIds.AvalancheMainnet]: 'avalanche',
+    [types_1.KnownChainIds.OptimismMainnet]: 'optimism',
+    [types_1.KnownChainIds.BnbSmartChainMainnet]: 'bsc',
+    [types_1.KnownChainIds.PolygonMainnet]: 'polygon',
+    [types_1.KnownChainIds.GnosisMainnet]: 'gnosis',
+    [types_1.KnownChainIds.ArbitrumMainnet]: 'arbitrum',
+    [types_1.KnownChainIds.BaseMainnet]: 'base',
+};

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

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

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

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.portalsApi = void 0;
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const utils_1 = require("../../utils");
+const getPortalsTradeQuote_1 = require("./getPortalsTradeQuote/getPortalsTradeQuote");
+const getPortalsTradeRate_1 = require("./getPortalsTradeRate/getPortalsTradeRate");
+exports.portalsApi = {
+    getTradeQuote: async (input, { config, assertGetEvmChainAdapter }) => {
+        const tradeQuoteResult = await (0, getPortalsTradeQuote_1.getPortalsTradeQuote)(input, assertGetEvmChainAdapter, config);
+        return tradeQuoteResult.map(tradeQuote => [tradeQuote]);
+    },
+    getTradeRate: async (input, { config, assertGetEvmChainAdapter }) => {
+        const tradeRateResult = await (0, getPortalsTradeRate_1.getPortalsTradeRate)(input, assertGetEvmChainAdapter, config);
+        return tradeRateResult.map(tradeRate => [tradeRate]);
+    },
+    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
+        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = (0, utils_1.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 chain_adapters_1.evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
+        return feeData.networkFeeCryptoBaseUnit;
+    },
+    getUnsignedEvmTransaction: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
+        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = (0, utils_1.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 chain_adapters_1.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_js_1.default.max(feeData.gasLimit, estimatedGas).toFixed(),
+        });
+    },
+    checkTradeStatus: utils_1.checkEvmSwapStatus,
+};

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

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,189 @@
+"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 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, supportsEIP1559, } = 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();
+        // 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;
+        // Use outputAmount from context, not estimate
+        const buyAmountAfterFeesCryptoBaseUnit = context.outputAmount;
+        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)(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: [
+                {
+                    // 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);