@shapeshiftoss/swapper 17.6.4 → 17.6.6-alpha.0

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

@@ -0,0 +1,28 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export { QuoteRequest } from '@defuse-protocol/one-click-sdk-typescript';
+export const nearIntentsSupportedChainIds = [
+    KnownChainIds.EthereumMainnet,
+    KnownChainIds.ArbitrumMainnet,
+    KnownChainIds.BaseMainnet,
+    KnownChainIds.GnosisMainnet,
+    KnownChainIds.BnbSmartChainMainnet,
+    KnownChainIds.PolygonMainnet,
+    KnownChainIds.AvalancheMainnet,
+    KnownChainIds.OptimismMainnet,
+    KnownChainIds.BitcoinMainnet,
+    KnownChainIds.DogecoinMainnet,
+    KnownChainIds.SolanaMainnet,
+];
+export const chainIdToNearIntentsChain = {
+    [KnownChainIds.EthereumMainnet]: 'eth',
+    [KnownChainIds.ArbitrumMainnet]: 'arb',
+    [KnownChainIds.BaseMainnet]: 'base',
+    [KnownChainIds.GnosisMainnet]: 'gnosis',
+    [KnownChainIds.BnbSmartChainMainnet]: 'bsc',
+    [KnownChainIds.PolygonMainnet]: 'pol',
+    [KnownChainIds.AvalancheMainnet]: 'avax',
+    [KnownChainIds.OptimismMainnet]: 'op',
+    [KnownChainIds.BitcoinMainnet]: 'btc',
+    [KnownChainIds.DogecoinMainnet]: 'doge',
+    [KnownChainIds.SolanaMainnet]: 'sol',
+};

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

@@ -0,0 +1,12 @@
+import type { Asset } from '@shapeshiftoss/types';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import type { TransactionInstruction } from '@solana/web3.js';
+import type { GetExecutionStatusResponse } from '../../types.js';
+export declare const calculateAccountCreationCosts: (instructions: TransactionInstruction[]) => string;
+export declare const getNearIntentsAsset: ({ nearNetwork, contractAddress, }: {
+    nearNetwork: string;
+    contractAddress: string;
+}) => string;
+export declare const assetToNearIntentsAsset: (asset: Asset) => Promise<string | null>;
+export declare const mapNearIntentsStatus: (status: GetExecutionStatusResponse['status']) => TxStatus;
+export declare const getNearIntentsStatusMessage: (status: GetExecutionStatusResponse['status']) => string | undefined;

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

@@ -0,0 +1,91 @@
+import { ASSOCIATED_PROGRAM_ID } from '@coral-xyz/anchor/dist/cjs/utils/token';
+import { fromAssetId, solanaChainId } from '@shapeshiftoss/caip';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import { bnOrZero, isToken } from '@shapeshiftoss/utils';
+import { zeroAddress } from 'viem';
+import { chainIdToNearIntentsChain } from '../../types.js';
+import { OneClickService } from '../oneClickService.js';
+const ATA_RENT_LAMPORTS = 2040000;
+export const calculateAccountCreationCosts = (instructions) => {
+    let totalCost = bnOrZero(0);
+    for (const ix of instructions) {
+        if (ix.programId.toString() === ASSOCIATED_PROGRAM_ID.toString()) {
+            totalCost = totalCost.plus(ATA_RENT_LAMPORTS);
+        }
+    }
+    return totalCost.toString();
+};
+export const getNearIntentsAsset = ({ nearNetwork, contractAddress, }) => {
+    // Native EVM assets: "nep141:eth.omft.near"
+    if (contractAddress === zeroAddress) {
+        return `nep141:${nearNetwork}.omft.near`;
+    }
+    // ERC20 tokens: "nep141:eth-0x{address}.omft.near"
+    return `nep141:${nearNetwork}-${contractAddress.toLowerCase()}.omft.near`;
+};
+const NEP245_CHAINS = ['bsc', 'pol', 'avax', 'op'];
+export const assetToNearIntentsAsset = async (asset) => {
+    const nearNetwork = chainIdToNearIntentsChain[asset.chainId];
+    if (!nearNetwork)
+        return null;
+    // NEP-245 chains (BSC, Polygon, Avalanche, Optimism) and Solana require token lookup
+    // Asset IDs use hashed format that can't be generated from contract addresses
+    const requiresLookup = NEP245_CHAINS.includes(nearNetwork) || asset.chainId === solanaChainId;
+    if (requiresLookup) {
+        const tokens = await OneClickService.getTokens();
+        const contractAddress = isToken(asset.assetId)
+            ? fromAssetId(asset.assetId).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 = isToken(asset.assetId)
+        ? fromAssetId(asset.assetId).assetReference
+        : zeroAddress;
+    return getNearIntentsAsset({ nearNetwork, contractAddress });
+};
+export const mapNearIntentsStatus = (status) => {
+    switch (status) {
+        case 'PENDING_DEPOSIT':
+        case 'KNOWN_DEPOSIT_TX':
+        case 'PROCESSING':
+            return TxStatus.Pending;
+        case 'SUCCESS':
+            return TxStatus.Confirmed;
+        case 'INCOMPLETE_DEPOSIT':
+        case 'REFUNDED':
+        case 'FAILED':
+            return TxStatus.Failed;
+        default:
+            return TxStatus.Unknown;
+    }
+};
+export 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';
+    }
+};

package/dist/esm/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/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/getPortalsTradeRate/getPortalsTradeRate.js

@@ -1,18 +1,19 @@
 import { fromAssetId } from '@shapeshiftoss/caip';
 import { evm } from '@shapeshiftoss/chain-adapters';
-import { bn, bnOrZero } from '@shapeshiftoss/utils';
+import { bn, bnOrZero, convertBasisPointsToDecimalPercentage } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { v4 as uuid } from 'uuid';
-import { zeroAddress } from 'viem';
+import { getAddress, zeroAddress } from 'viem';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../index.js';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
-import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
+import { simulateWithStateOverrides } from '../../../utils/tenderly/index.js';
+import { getTreasuryAddressFromChainId, isNativeEvmAsset } from '../../utils/helpers/helpers.js';
 import { chainIdToPortalsNetwork } from '../constants.js';
-import { fetchPortalsTradeEstimate } from '../utils/fetchPortalsTradeOrder.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, } = input;
+    const { sellAsset, buyAsset, accountNumber, affiliateBps, chainId, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, supportsEIP1559, } = input;
     const adapter = assertGetEvmChainAdapter(chainId);
     const sellAssetChainId = sellAsset.chainId;
     const buyAssetChainId = buyAsset.chainId;
@@ -61,16 +62,32 @@ export async function getPortalsTradeRate(input, assertGetEvmChainAdapter, swapp
             : bnOrZero(getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Portals))
                 .times(100)
                 .toNumber();
-        const quoteEstimateResponse = await fetchPortalsTradeEstimate({
+        // 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,
         });
-        // 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
+        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,
@@ -80,21 +97,47 @@ export async function getPortalsTradeRate(input, assertGetEvmChainAdapter, swapp
         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(quoteEstimateResponse.outputAmount)
-            .minus(quoteEstimateResponse.minOutputAmount)
-            .div(quoteEstimateResponse.outputAmount)
+        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(quoteEstimateResponse.minOutputAmount)
+        const buyAmountBeforeSlippageCryptoBaseUnit = bnOrZero(context.minOutputAmount)
             .div(bn(1).minus(actualBufferDecimal))
             .toFixed(0);
         const slippageTolerancePercentageDecimal = actualBufferDecimal;
-        const gasLimit = quoteEstimateResponse.context.gasLimit;
+        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(input.supportsEIP1559),
-            gasLimit: gasLimit.toString(),
+            supportsEIP1559: Boolean(supportsEIP1559),
+            gasLimit,
         });
         const tradeRate = {
             id: uuid(),

package/dist/esm/swappers/RelaySwapper/constant.js

@@ -49,6 +49,7 @@ export const DEFAULT_RELAY_SOLANA_USER_ADDRESS = 'CbKGgVKLJFb8bBrf58DnAkdryX6ube
 export const MAXIMUM_SUPPORTED_RELAY_STEPS = 2;
 export const relayErrorCodeToTradeQuoteError = {
     [RelayErrorCode.AmountTooLow]: TradeQuoteError.SellAmountBelowMinimum,
+    [RelayErrorCode.ChainDisabled]: TradeQuoteError.TradingHalted,
     [RelayErrorCode.Erc20RouterAddressNotFound]: TradeQuoteError.UnsupportedTradePair,
     [RelayErrorCode.ExtraTransactionsNotSupported]: TradeQuoteError.UnsupportedTradePair,
     [RelayErrorCode.InsufficientFunds]: TradeQuoteError.SellAmountBelowTradeFee,

package/dist/esm/swappers/RelaySwapper/utils/fetchRelayTrade.d.ts

@@ -1,5 +1,5 @@
 import type { Result } from '@sniptt/monads';
 import type { AxiosResponse } from 'axios';
-import type { SwapErrorRight, SwapperConfig } from 'packages/swapper/src/types';
+import type { SwapErrorRight, SwapperConfig } from '../../../types.js';
 import type { RelayFetchQuoteParams, RelayQuote } from './types.js';
 export declare const fetchRelayTrade: <T extends "rate" | "quote">(params: RelayFetchQuoteParams<T>, config: SwapperConfig) => Promise<Result<AxiosResponse<RelayQuote, any>, SwapErrorRight>>;

package/dist/esm/swappers/RelaySwapper/utils/getRelayPsbtRelayer.js

@@ -1,7 +1,7 @@
 import * as bitcoin from '@shapeshiftoss/bitcoinjs-lib';
 export const getRelayPsbtRelayer = (psbtHex, sellAmountCryptoBaseUnit) => {
     const psbtBuffer = Buffer.from(psbtHex, 'hex');
-    const psbt = bitcoin.Psbt.fromBuffer(new Uint8Array(psbtBuffer));
+    const psbt = bitcoin.Psbt.fromBuffer(psbtBuffer);
     const outputs = psbt.txOutputs;
     for (let i = 0; i < outputs.length; i++) {
         const output = outputs[i];
@@ -9,7 +9,7 @@ export const getRelayPsbtRelayer = (psbtHex, sellAmountCryptoBaseUnit) => {
         try {
             const address = bitcoin.address.fromOutputScript(script);
             // Assuming the destination address is the one with the exact amount of sellAmountCryptoBaseUnit
-            if (output.value === BigInt(sellAmountCryptoBaseUnit)) {
+            if (output.value === Number(sellAmountCryptoBaseUnit)) {
                 return address;
             }
         }

package/dist/esm/swappers/RelaySwapper/utils/getTrade.js

@@ -1,12 +1,13 @@
 import { btcChainId, fromChainId, solanaChainId } from '@shapeshiftoss/caip';
-import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { evm, isEvmChainId } from '@shapeshiftoss/chain-adapters';
 import { bnOrZero, convertBasisPointsToPercentage, convertDecimalPercentageToBasisPoints, convertPrecision, DAO_TREASURY_BASE, } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { PublicKey } from '@solana/web3.js';
 import axios from 'axios';
-import { zeroAddress } from 'viem';
+import { getAddress, zeroAddress } from 'viem';
 import { MixPanelEvent, SwapperName, TradeQuoteError } from '../../../types.js';
 import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { simulateWithStateOverrides } from '../../../utils/tenderly/index.js';
 import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
 import { MAXIMUM_SUPPORTED_RELAY_STEPS, relayErrorCodeToTradeQuoteError } from '../constant.js';
 import { getRelayAssetAddress } from '../utils/getRelayAssetAddress.js';
@@ -126,6 +127,11 @@ export async function getTrade({ input, deps, relayChainMap, }) {
                 code: tradeQuoteErrorCode,
             }));
         }
+        // Fallback for unmapped error codes (shouldn't happen, but prevents crashes)
+        return Err(makeSwapErrorRight({
+            message: relayError.message || 'Unknown Relay error',
+            code: TradeQuoteError.UnknownError,
+        }));
     }
     const { data: quote } = maybeQuote.unwrap();
     const { slippageTolerance, currencyOut, timeEstimate } = quote.details;
@@ -327,6 +333,45 @@ export async function getTrade({ input, deps, relayChainMap, }) {
             const feeData = await adapter.getFeeData(getFeeDataInput);
             return feeData.fast.txFee;
         }
+        // Use Tenderly simulation with state overrides for EVM chains
+        if (isEvmChainId(sellAsset.chainId)) {
+            const firstStep = swapSteps[0];
+            const selectedItem = firstStep?.items?.[0];
+            if (selectedItem?.data && isRelayQuoteEvmItemData(selectedItem.data)) {
+                try {
+                    const tenderlySimulation = await simulateWithStateOverrides({
+                        chainId: sellAsset.chainId,
+                        // NOTE: zeroAddress is here purely for the purpose of satisfying the type sistem
+                        // That should never happen
+                        from: getAddress(sendAddress ?? zeroAddress),
+                        to: getAddress(selectedItem.data.to ?? zeroAddress),
+                        data: (selectedItem.data.data ?? '0x'),
+                        value: selectedItem.data.value ?? '0',
+                        sellAsset,
+                    }, {
+                        apiKey: deps.config.VITE_TENDERLY_API_KEY,
+                        accountSlug: deps.config.VITE_TENDERLY_ACCOUNT_SLUG,
+                        projectSlug: deps.config.VITE_TENDERLY_PROJECT_SLUG,
+                    });
+                    if (tenderlySimulation.success) {
+                        // Use Tenderly's gas estimate instead of Relay's
+                        const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+                        const { average } = await adapter.getGasFeeData();
+                        const supportsEIP1559 = 'maxFeePerGas' in average;
+                        const tenderlyNetworkFee = evm.calcNetworkFeeCryptoBaseUnit({
+                            ...average,
+                            supportsEIP1559,
+                            gasLimit: tenderlySimulation.gasLimit.toString(),
+                        });
+                        return tenderlyNetworkFee;
+                    }
+                }
+                catch (error) {
+                    // Silently fall through to use Relay's gas estimate
+                }
+            }
+        }
+        // Fallback to Relay's gas amount
         return quote.fees.gas.amount;
     })();
     const steps = swapSteps.map((quoteStep) => {

package/dist/esm/swappers/RelaySwapper/utils/notifyTransactionIndexing.d.ts

@@ -1,6 +1,6 @@
 import type { Result } from '@sniptt/monads';
 import type { AxiosResponse } from 'axios';
-import type { SwapErrorRight, SwapperConfig } from 'packages/swapper/src/types';
+import type { SwapErrorRight, SwapperConfig } from '../../../types.js';
 import type { RelayQuote } from './types.js';
 type NotifyTransactionIndexingParams = {
     requestId: string;

package/dist/esm/swappers/RelaySwapper/utils/relayTokenToAssetId.js

@@ -20,8 +20,6 @@ export const relayTokenToAssetId = (relayToken) => {
         if (!isNativeAsset) {
             const assetNamespace = (() => {
                 switch (true) {
-                    case CHAIN_REFERENCE.BnbSmartChainMainnet === chainReference:
-                        return ASSET_NAMESPACE.bep20;
                     case isEvmChainId(chainId):
                         return ASSET_NAMESPACE.erc20;
                     case CHAIN_REFERENCE.SolanaMainnet === chainReference:

package/dist/esm/swappers/RelaySwapper/utils/types.d.ts

@@ -131,6 +131,7 @@ export type RelaySolanaInstruction = {
 };
 export declare enum RelayErrorCode {
     AmountTooLow = "AMOUNT_TOO_LOW",
+    ChainDisabled = "CHAIN_DISABLED",
     Erc20RouterAddressNotFound = "ERC20_ROUTER_ADDRESS_NOT_FOUND",
     ExtraTransactionsNotSupported = "EXTRA_TXS_NOT_SUPPORTED",
     InsufficientFunds = "INSUFFICIENT_FUNDS",

package/dist/esm/swappers/RelaySwapper/utils/types.js

@@ -10,6 +10,7 @@ export const isRelayQuoteSolanaItemData = (item) => {
 export var RelayErrorCode;
 (function (RelayErrorCode) {
     RelayErrorCode["AmountTooLow"] = "AMOUNT_TOO_LOW";
+    RelayErrorCode["ChainDisabled"] = "CHAIN_DISABLED";
     RelayErrorCode["Erc20RouterAddressNotFound"] = "ERC20_ROUTER_ADDRESS_NOT_FOUND";
     RelayErrorCode["ExtraTransactionsNotSupported"] = "EXTRA_TXS_NOT_SUPPORTED";
     RelayErrorCode["InsufficientFunds"] = "INSUFFICIENT_FUNDS";