@shapeshiftoss/swapper 17.8.0 → 19.0.0

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

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNearIntentsStepData = exports.NEAR_INTENTS_SOLANA_COMPUTE_BUDGET = 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 types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const evm_1 = require("../../../utils/evm");
+const helpers_1 = require("../../../utils/helpers");
+const solana_1 = require("../../../utils/solana");
+const utxo_1 = require("../../../utils/utxo");
+// Deposits are plain (token) transfers with constant measured compute consumption (max 15394 CU
+// with ata creation), so the margin is safety only; the floor guarantees the limit covers full
+// ata recreation if the deposit ata is closed between simulation and landing (a no-op create
+// simulates ~3x cheaper than a real one)
+exports.NEAR_INTENTS_SOLANA_COMPUTE_BUDGET = {
+    marginMultiplier: 1.1,
+    minComputeUnits: 20_000,
+};
+async function getNearIntentsStepData(args) {
+    const { deps, type, input, sellAsset, sellAmountCryptoBaseUnit, from, depositAddress } = args;
+    const { chainNamespace } = (0, caip_1.fromAssetId)(sellAsset.assetId);
+    const contractAddress = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
+    try {
+        switch (chainNamespace) {
+            case caip_1.CHAIN_NAMESPACE.Evm: {
+                const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+                const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
+                const transactionData = {
+                    type: 'evm',
+                    chainId: Number((0, caip_1.fromChainId)(sellAsset.chainId).chainReference),
+                    to: contractAddress ?? depositAddress,
+                    data: chain_adapters_1.evm.getErc20Data(depositAddress, sellAmountCryptoBaseUnit, contractAddress) || '0x',
+                    value: (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId) ? sellAmountCryptoBaseUnit : '0',
+                };
+                const stateOverride = {
+                    sellAsset,
+                    sellAmountCryptoBaseUnit,
+                };
+                // The deposit is a plain (token) transfer with no approval involved - overridden
+                // estimation still prices an unfunded sender, so rates work walletless via the placeholder
+                if (type === 'rate') {
+                    const networkFeeCryptoBaseUnit = await (async () => {
+                        try {
+                            return await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+                                adapter,
+                                transactionData,
+                                from: from || evm_1.EVM_PLACEHOLDER_ADDRESS,
+                                supportsEIP1559,
+                                stateOverride,
+                            });
+                        }
+                        catch {
+                            return undefined;
+                        }
+                    })();
+                    const stepData = { networkFeeCryptoBaseUnit };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+                    adapter,
+                    transactionData,
+                    from: from || depositAddress,
+                    supportsEIP1559,
+                    stateOverride,
+                });
+                const stepData = { transactionData, networkFeeCryptoBaseUnit };
+                return (0, monads_1.Ok)(stepData);
+            }
+            case caip_1.CHAIN_NAMESPACE.Utxo: {
+                const adapter = deps.assertGetUtxoChainAdapter(sellAsset.chainId);
+                const { networkFeeCryptoBaseUnit } = await (0, utxo_1.getUtxoNetworkFeeCryptoBaseUnit)({
+                    adapter,
+                    pubkey: 'xpub' in input ? input.xpub : undefined,
+                    to: depositAddress,
+                    value: sellAmountCryptoBaseUnit,
+                });
+                if (type === 'rate') {
+                    const stepData = { networkFeeCryptoBaseUnit };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                const stepData = {
+                    transactionData: { type: 'utxo', to: depositAddress, value: sellAmountCryptoBaseUnit },
+                    networkFeeCryptoBaseUnit,
+                };
+                return (0, monads_1.Ok)(stepData);
+            }
+            case caip_1.CHAIN_NAMESPACE.Solana: {
+                const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+                const tokenId = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
+                if (type === 'rate') {
+                    // Rates estimate with a transfer from the send address, or a self transfer from the
+                    // funded placeholder (1 lamport, native shape) when no wallet is connected; fresh
+                    // deposit addresses always need their token account created, so rent is included
+                    const address = from ?? solana_1.SOLANA_PLACEHOLDER_ADDRESS;
+                    const instructions = await adapter.buildTransferInstructions({
+                        from: address,
+                        to: from ? depositAddress : address,
+                        tokenId: from ? tokenId : undefined,
+                        value: from ? sellAmountCryptoBaseUnit : '1',
+                    });
+                    const { networkFeeCryptoBaseUnit: transactionFeeCryptoBaseUnit } = await (0, solana_1.getSolanaNetworkFeeCryptoBaseUnit)({
+                        adapter,
+                        from: address,
+                        instructions,
+                        tokenId,
+                    });
+                    // The walletless native shape can't include the deposit token account creation
+                    const ataCreationRent = !from && tokenId ? solana_1.ATA_RENT_LAMPORTS : 0;
+                    const stepData = {
+                        networkFeeCryptoBaseUnit: (0, utils_1.bn)(transactionFeeCryptoBaseUnit)
+                            .plus(ataCreationRent)
+                            .toString(),
+                    };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                const instructions = await adapter.buildTransferInstructions({
+                    from,
+                    to: depositAddress,
+                    tokenId,
+                    value: sellAmountCryptoBaseUnit,
+                });
+                const { networkFeeCryptoBaseUnit, feeData, includeComputeBudget } = await (0, solana_1.getSolanaNetworkFeeCryptoBaseUnit)({
+                    adapter,
+                    from,
+                    instructions,
+                    tokenId,
+                });
+                const transactionData = {
+                    type: 'solana_instructions',
+                    instructions: (0, solana_1.withComputeUnitLimit)({
+                        instructions,
+                        computeUnits: feeData.chainSpecific.computeUnits,
+                        includeComputeBudget,
+                        computeBudget: exports.NEAR_INTENTS_SOLANA_COMPUTE_BUDGET,
+                    }),
+                    addressLookupTableAddresses: [],
+                };
+                const stepData = { transactionData, networkFeeCryptoBaseUnit };
+                return (0, monads_1.Ok)(stepData);
+            }
+            case caip_1.CHAIN_NAMESPACE.Tron: {
+                const { fast } = await deps.assertGetTronChainAdapter(sellAsset.chainId).getFeeData({
+                    to: depositAddress,
+                    value: sellAmountCryptoBaseUnit,
+                    chainSpecific: {
+                        from,
+                        contractAddress: (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId),
+                    },
+                });
+                const stepData = { networkFeeCryptoBaseUnit: fast.txFee };
+                return (0, monads_1.Ok)(stepData);
+            }
+            case caip_1.CHAIN_NAMESPACE.Sui: {
+                if (!from) {
+                    const stepData = { networkFeeCryptoBaseUnit: undefined };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                const { fast } = await deps.assertGetSuiChainAdapter(sellAsset.chainId).getFeeData({
+                    to: depositAddress,
+                    value: sellAmountCryptoBaseUnit,
+                    chainSpecific: {
+                        from,
+                        tokenId: (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId),
+                    },
+                    sendMax: false,
+                });
+                const stepData = { networkFeeCryptoBaseUnit: fast.txFee };
+                return (0, monads_1.Ok)(stepData);
+            }
+            case caip_1.CHAIN_NAMESPACE.Starknet: {
+                if (!from) {
+                    const stepData = { networkFeeCryptoBaseUnit: undefined };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                const { fast } = await deps.assertGetStarknetChainAdapter(sellAsset.chainId).getFeeData({
+                    to: depositAddress,
+                    value: sellAmountCryptoBaseUnit,
+                    chainSpecific: {
+                        from,
+                        tokenContractAddress: (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId),
+                    },
+                    sendMax: false,
+                });
+                const stepData = { networkFeeCryptoBaseUnit: fast.txFee };
+                return (0, monads_1.Ok)(stepData);
+            }
+            case caip_1.CHAIN_NAMESPACE.Near: {
+                if (!from) {
+                    const stepData = { networkFeeCryptoBaseUnit: undefined };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                const { fast } = await deps.assertGetNearChainAdapter(sellAsset.chainId).getFeeData({
+                    to: depositAddress,
+                    value: sellAmountCryptoBaseUnit,
+                    chainSpecific: { from },
+                });
+                const stepData = { networkFeeCryptoBaseUnit: fast.txFee };
+                return (0, monads_1.Ok)(stepData);
+            }
+            case caip_1.CHAIN_NAMESPACE.Ton: {
+                if (!from) {
+                    const stepData = { networkFeeCryptoBaseUnit: undefined };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                const { fast } = await deps.assertGetTonChainAdapter(sellAsset.chainId).getFeeData({
+                    to: depositAddress,
+                    value: sellAmountCryptoBaseUnit,
+                    chainSpecific: {
+                        from,
+                        contractAddress: (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId),
+                    },
+                });
+                const stepData = { networkFeeCryptoBaseUnit: fast.txFee };
+                return (0, monads_1.Ok)(stepData);
+            }
+            default:
+                return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                    message: `[getNearIntentsStepData] unsupported chain namespace: ${chainNamespace}`,
+                    code: types_1.TradeQuoteError.UnsupportedChain,
+                }));
+        }
+    }
+    catch (error) {
+        // Rates are best effort with no provider fee to degrade to; quotes must price to execute
+        if (type === 'rate') {
+            const stepData = { networkFeeCryptoBaseUnit: undefined };
+            return (0, monads_1.Ok)(stepData);
+        }
+        return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getNearIntentsStepData', error));
+    }
+}
+exports.getNearIntentsStepData = getNearIntentsStepData;

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

@@ -0,0 +1,21 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types';
+import type { NearIntentsTradeQuoteInput, NearIntentsTradeRateInput, QuoteResponse } from '../types';
+type NearIntentsTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    stepDataArgs: {
+        deps: SwapperDeps;
+        sellAsset: Asset;
+        sellAmountCryptoBaseUnit: string;
+        depositAddress: string;
+    };
+};
+export declare const getNearIntentsTradeContext: ({ input, deps, quote, }: {
+    input: NearIntentsTradeQuoteInput | NearIntentsTradeRateInput;
+    deps: SwapperDeps;
+    quote: QuoteResponse['quote'];
+}) => Result<NearIntentsTradeContext, SwapErrorRight>;
+export {};

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNearIntentsTradeContext = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const uuid_1 = require("uuid");
+const constants_1 = require("../../../constants");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const affiliateFee_1 = require("../../../utils/affiliateFee");
+const getNearIntentsTradeContext = ({ input, deps, quote, }) => {
+    const { sellAsset, buyAsset, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit, slippageTolerancePercentageDecimal, } = input;
+    if (!quote.depositAddress)
+        return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getNearIntentsTradeContext'));
+    const rate = (0, utils_2.getInputOutputRate)({
+        sellAmountCryptoBaseUnit: quote.amountIn,
+        buyAmountCryptoBaseUnit: quote.amountOut,
+        sellAsset,
+        buyAsset,
+    });
+    return (0, monads_1.Ok)({
+        tradeCommon: {
+            id: (0, uuid_1.v4)(),
+            rate,
+            swapperName: types_1.SwapperName.NearIntents,
+            affiliateBps,
+            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ??
+                (0, constants_1.getDefaultSlippageDecimalPercentageForSwapper)(types_1.SwapperName.NearIntents),
+        },
+        stepCommon: {
+            allowanceContract: '',
+            buyAmountBeforeFeesCryptoBaseUnit: quote.amountOut,
+            buyAmountAfterFeesCryptoBaseUnit: quote.amountOut,
+            buyAsset,
+            rate,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit: quote.amountIn,
+            sellAsset,
+            source: types_1.SwapperName.NearIntents,
+            estimatedExecutionTimeMs: quote.timeEstimate ? quote.timeEstimate * 1000 : undefined,
+            affiliateFee: (0, affiliateFee_1.buildAffiliateFee)({
+                strategy: 'fixed_asset',
+                affiliateBps,
+                sellAsset,
+                buyAsset,
+                sellAmountCryptoBaseUnit: quote.amountIn,
+                buyAmountCryptoBaseUnit: quote.amountOut,
+                fixedAssetId: (0, utils_1.chainIdToFeeAssetId)(caip_1.nearChainId),
+                fixedAsset: deps.assetsById[(0, utils_1.chainIdToFeeAssetId)(caip_1.nearChainId)],
+                isEstimate: true,
+            }),
+        },
+        protocolFees: {},
+        stepDataArgs: {
+            deps,
+            sellAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            depositAddress: quote.depositAddress,
+        },
+    });
+};
+exports.getNearIntentsTradeContext = getNearIntentsTradeContext;

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

@@ -0,0 +1,40 @@
+import type { Asset } from '@shapeshiftoss/types';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types';
+import type { GetExecutionStatusResponse, QuoteResponse } from '../types';
+import { QuoteRequest } from '../types';
+export declare const getNearIntentsAsset: ({ nearNetwork, contractAddress, }: {
+    nearNetwork: string;
+    contractAddress: string;
+}) => string;
+export declare const assetToNearIntentsAsset: (asset: Asset) => Promise<string | null>;
+export declare const resolveNearIntentsAssets: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Promise<Result<{
+    originAsset: string;
+    destinationAsset: string;
+}, SwapErrorRight>>;
+export declare const getNearIntentsQuoteDeadline: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => string;
+export declare const buildNearIntentsQuoteRequest: ({ originAsset, destinationAsset, sellAmountCryptoBaseUnit, slippageTolerancePercentageDecimal, affiliateBps, refundTo, recipient, refundType, recipientType, deadline, }: {
+    originAsset: string;
+    destinationAsset: string;
+    sellAmountCryptoBaseUnit: string;
+    slippageTolerancePercentageDecimal: string | undefined;
+    affiliateBps: string;
+    refundTo: string;
+    recipient: string;
+    refundType: QuoteRequest.refundType;
+    recipientType: QuoteRequest.recipientType;
+    deadline: string;
+}) => QuoteRequest;
+export declare const fetchNearIntentsQuote: ({ quoteRequest, sellAsset, }: {
+    quoteRequest: QuoteRequest;
+    sellAsset: Asset;
+}) => Promise<Result<QuoteResponse, SwapErrorRight>>;
+export declare const mapNearIntentsStatus: (status: GetExecutionStatusResponse['status']) => TxStatus;
+export declare const getNearIntentsStatusMessage: (status: GetExecutionStatusResponse['status']) => string | undefined;

package/dist/cjs/swappers/NearIntentsSwapper/utils/{helpers/helpers.js → helpers.js}

@@ -1,13 +1,16 @@
 "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");
+exports.getNearIntentsStatusMessage = exports.mapNearIntentsStatus = exports.fetchNearIntentsQuote = exports.buildNearIntentsQuoteRequest = exports.getNearIntentsQuoteDeadline = exports.resolveNearIntentsAssets = exports.assetToNearIntentsAsset = exports.getNearIntentsAsset = void 0;
 const caip_1 = require("@shapeshiftoss/caip");
 const unchained_client_1 = require("@shapeshiftoss/unchained-client");
 const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
 const viem_1 = require("viem");
-const types_1 = require("../../types");
-const oneClickService_1 = require("../oneClickService");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const constants_1 = require("../constants");
+const types_2 = require("../types");
+const oneClickService_1 = require("./oneClickService");
 const getTokensWithRetry = async () => {
     const maxRetries = 3;
     let lastError = null;
@@ -27,17 +30,6 @@ const getTokensWithRetry = async () => {
     }
     throw lastError ?? new Error('Failed to get tokens after retries');
 };
-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) {
@@ -59,7 +51,7 @@ const isTokenLookupChain = (chain) => {
     return TOKEN_LOOKUP_CHAINS.includes(chain);
 };
 const assetToNearIntentsAsset = async (asset) => {
-    const nearNetwork = types_1.chainIdToNearIntentsChain[asset.chainId];
+    const nearNetwork = types_2.chainIdToNearIntentsChain[asset.chainId];
     if (!nearNetwork)
         return null;
     // https://partners.near-intents.org/omni-migration#partners
@@ -107,6 +99,109 @@ const assetToNearIntentsAsset = async (asset) => {
     return (0, exports.getNearIntentsAsset)({ nearNetwork, contractAddress });
 };
 exports.assetToNearIntentsAsset = assetToNearIntentsAsset;
+const resolveNearIntentsAssets = async ({ sellAsset, buyAsset, }) => {
+    try {
+        const originAsset = await (0, exports.assetToNearIntentsAsset)(sellAsset);
+        const destinationAsset = await (0, exports.assetToNearIntentsAsset)(buyAsset);
+        if (!originAsset) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                code: types_1.TradeQuoteError.UnsupportedTradePair,
+                message: `Asset ${sellAsset.symbol} on ${sellAsset.networkName || sellAsset.chainId} is not supported by NEAR Intents`,
+            }));
+        }
+        if (!destinationAsset) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                code: types_1.TradeQuoteError.UnsupportedTradePair,
+                message: `Asset ${buyAsset.symbol} on ${buyAsset.networkName || buyAsset.chainId} is not supported by NEAR Intents`,
+            }));
+        }
+        return (0, monads_1.Ok)({ originAsset, destinationAsset });
+    }
+    catch (error) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: error instanceof Error ? error.message : 'Failed to resolve NEAR Intents assets',
+            code: types_1.TradeQuoteError.QueryFailed,
+            cause: error,
+        }));
+    }
+};
+exports.resolveNearIntentsAssets = resolveNearIntentsAssets;
+// BTC deposits confirm slowly, so BTC pairs get a longer deadline
+const getNearIntentsQuoteDeadline = ({ sellAsset, buyAsset, }) => {
+    const deadlineMs = sellAsset.chainId === caip_1.btcChainId || buyAsset.chainId === caip_1.btcChainId
+        ? constants_1.BTC_QUOTE_DEADLINE_MS
+        : constants_1.DEFAULT_QUOTE_DEADLINE_MS;
+    return new Date(Date.now() + deadlineMs).toISOString();
+};
+exports.getNearIntentsQuoteDeadline = getNearIntentsQuoteDeadline;
+const buildNearIntentsQuoteRequest = ({ originAsset, destinationAsset, sellAmountCryptoBaseUnit, slippageTolerancePercentageDecimal, affiliateBps, refundTo, recipient, refundType, recipientType, deadline, }) => ({
+    dry: false,
+    swapType: types_2.QuoteRequest.swapType.EXACT_INPUT,
+    slippageTolerance: slippageTolerancePercentageDecimal
+        ? (0, utils_1.bnOrZero)(slippageTolerancePercentageDecimal).times(10000).toNumber()
+        : constants_1.DEFAULT_SLIPPAGE_BPS,
+    originAsset,
+    destinationAsset,
+    amount: sellAmountCryptoBaseUnit,
+    depositType: types_2.QuoteRequest.depositType.ORIGIN_CHAIN,
+    refundTo,
+    refundType,
+    recipient,
+    recipientType,
+    deadline,
+    referral: 'shapeshift',
+    appFees: [
+        {
+            recipient: utils_1.DAO_TREASURY_NEAR,
+            fee: Number(affiliateBps),
+        },
+    ],
+});
+exports.buildNearIntentsQuoteRequest = buildNearIntentsQuoteRequest;
+// One retry loop for the SDK's flaky WebSocket transport; maps provider errors to swap errors
+const fetchNearIntentsQuote = async ({ quoteRequest, sellAsset, }) => {
+    const maxRetries = 3;
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            return (0, monads_1.Ok)(await oneClickService_1.OneClickService.getQuote(quoteRequest));
+        }
+        catch (err) {
+            lastError = err instanceof Error ? err : new Error(String(err));
+            const isWebSocketError = lastError.message.includes('WebSocket is not ready');
+            if (isWebSocketError && attempt < maxRetries) {
+                await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
+                continue;
+            }
+            break;
+        }
+    }
+    const error = lastError ?? new Error('Failed to get quote after retries');
+    if (error instanceof oneClickService_1.ApiError) {
+        if (error.body?.message === 'tokenIn is not valid' ||
+            error.body?.message === 'tokenOut is not valid') {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                code: types_1.TradeQuoteError.UnsupportedTradePair,
+                message: 'Unsupported asset',
+            }));
+        }
+        if (error.body?.message?.includes('Amount is too low')) {
+            const match = error.body.message.match(/try at least (\d+)/);
+            if (match) {
+                return (0, monads_1.Err)((0, utils_2.createTradeAmountTooSmallErr)({
+                    minAmountCryptoBaseUnit: match[1],
+                    assetId: sellAsset.assetId,
+                }));
+            }
+        }
+    }
+    return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+        message: error instanceof Error ? error.message : 'Unknown error getting NEAR Intents quote',
+        code: types_1.TradeQuoteError.QueryFailed,
+        cause: error,
+    }));
+};
+exports.fetchNearIntentsQuote = fetchNearIntentsQuote;
 const mapNearIntentsStatus = (status) => {
     switch (status) {
         case 'PENDING_DEPOSIT':

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

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

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

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.chainIdToPortalsNetwork = void 0;
+exports.chainIdToPortalsNetwork = exports.PORTALS_RATE_DEFAULT_ADDRESS = void 0;
 const types_1 = require("@shapeshiftoss/types");
+// Vitalik's address — a realistic connected-wallet stand-in for walletless rate pricing + simulation
+exports.PORTALS_RATE_DEFAULT_ADDRESS = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045';
 exports.chainIdToPortalsNetwork = {
     [types_1.KnownChainIds.EthereumMainnet]: 'ethereum',
     [types_1.KnownChainIds.AvalancheMainnet]: 'avalanche',
@@ -11,4 +13,6 @@ exports.chainIdToPortalsNetwork = {
     [types_1.KnownChainIds.ArbitrumMainnet]: 'arbitrum',
     [types_1.KnownChainIds.BaseMainnet]: 'base',
     [types_1.KnownChainIds.HyperEvmMainnet]: 'hyperevm',
+    [types_1.KnownChainIds.SonicMainnet]: 'sonic',
+    [types_1.KnownChainIds.PlasmaMainnet]: 'plasma',
 };

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

@@ -1,60 +1,18 @@
 "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 unchained_client_1 = require("@shapeshiftoss/unchained-client");
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
 const utils_1 = require("../../utils");
+const evm_1 = require("../../utils/evm");
 const getPortalsTradeQuote_1 = require("./getPortalsTradeQuote/getPortalsTradeQuote");
 const getPortalsTradeRate_1 = require("./getPortalsTradeRate/getPortalsTradeRate");
 const fetchAxelarscanStatus_1 = require("./utils/fetchAxelarscanStatus");
 const fetchSquidStatus_1 = require("./utils/fetchSquidStatus");
 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(),
-        });
-    },
+    getTradeQuote: (input, deps) => (0, getPortalsTradeQuote_1.getPortalsTradeQuote)(input, deps),
+    getTradeRate: (input, deps) => (0, getPortalsTradeRate_1.getPortalsTradeRate)(input, deps),
+    getEvmTransactionFees: evm_1.getEvmTransactionFees,
+    getUnsignedEvmTransaction: evm_1.getUnsignedEvmTransaction,
     checkTradeStatus: async (input) => {
         const { txHash, chainId, swap, assertGetEvmChainAdapter, address, fetchIsSmartContractAddressQuery, } = input;
         const isCrossChain = Boolean(swap && swap.sellAsset.chainId !== swap.buyAsset?.chainId);
@@ -103,14 +61,14 @@ exports.portalsApi = {
                 return {
                     status: squidTxStatus,
                     buyTxHash: squidStatus.destinationTxHash,
-                    relayerExplorerTxLink: (0, fetchSquidStatus_1.getSquidTrackingLink)(txHash, squidStatus, swap.sellAsset.explorerTxLink, swap.buyAsset.explorerTxLink),
+                    swapperTxLink: (0, fetchSquidStatus_1.getSquidTrackingLink)(txHash, squidStatus, swap.sellAsset.explorerTxLink, swap.buyAsset.explorerTxLink),
                     message: squidTxStatus === unchained_client_1.TxStatus.Pending ? 'Cross-chain swap in progress' : undefined,
                 };
             }
             return {
                 status: unchained_client_1.TxStatus.Pending,
                 buyTxHash: undefined,
-                relayerExplorerTxLink: (0, fetchAxelarscanStatus_1.getAxelarscanTrackingLink)(txHash),
+                swapperTxLink: (0, fetchAxelarscanStatus_1.getAxelarscanTrackingLink)(txHash),
                 message: 'Bridge status check failed - track manually',
             };
         }
@@ -136,7 +94,7 @@ exports.portalsApi = {
         return {
             status: txStatus,
             buyTxHash: bridgeStatus.destinationTxHash,
-            relayerExplorerTxLink: (0, fetchAxelarscanStatus_1.getAxelarscanTrackingLink)(txHash),
+            swapperTxLink: (0, fetchAxelarscanStatus_1.getAxelarscanTrackingLink)(txHash),
             message: txStatus === unchained_client_1.TxStatus.Pending
                 ? 'Bridge in progress'
                 : txStatus === unchained_client_1.TxStatus.Failed

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

@@ -1,5 +1,4 @@
-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>>;
+import type { SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types';
+import type { PortalsTradeQuoteInput } from '../types';
+export declare const getPortalsTradeQuote: (input: PortalsTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;