@shapeshiftoss/swapper 17.6.7 → 17.6.9

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

@@ -1,40 +1,33 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateSwapAmounts = exports.findBestPool = exports.calculateAmountLimit = exports.determineSwapDirection = exports.getCoinType = exports.getCetusSDK = void 0;
+exports.findBestRoute = exports.getCoinType = exports.getSuiClient = exports.getAggregatorClient = void 0;
+const aggregator_sdk_1 = require("@cetusprotocol/aggregator-sdk");
+const client_1 = require("@cetusprotocol/aggregator-sdk/node_modules/@mysten/sui/client");
 const caip_1 = require("@shapeshiftoss/caip");
-const utils_1 = require("@shapeshiftoss/utils");
-let sdkInstance;
-const getCetusSDK = async () => {
-    if (!sdkInstance) {
-        const { initMainnetSDK } = await Promise.resolve().then(() => __importStar(require('@cetusprotocol/cetus-sui-clmm-sdk')));
-        sdkInstance = initMainnetSDK();
+let suiClientInstance;
+let aggregatorClientInstance;
+let currentRpcUrl;
+const getAggregatorClient = (rpcUrl) => {
+    if (!aggregatorClientInstance || !suiClientInstance || currentRpcUrl !== rpcUrl) {
+        suiClientInstance = new client_1.SuiClient({ url: rpcUrl });
+        aggregatorClientInstance = new aggregator_sdk_1.AggregatorClient({
+            client: suiClientInstance,
+            env: aggregator_sdk_1.Env.Mainnet,
+            signer: '0x0',
+        });
+        currentRpcUrl = rpcUrl;
+    }
+    return aggregatorClientInstance;
+};
+exports.getAggregatorClient = getAggregatorClient;
+const getSuiClient = (rpcUrl) => {
+    if (!suiClientInstance || currentRpcUrl !== rpcUrl) {
+        suiClientInstance = new client_1.SuiClient({ url: rpcUrl });
+        currentRpcUrl = rpcUrl;
     }
-    return sdkInstance;
+    return suiClientInstance;
 };
-exports.getCetusSDK = getCetusSDK;
+exports.getSuiClient = getSuiClient;
 const getCoinType = (asset) => {
     const { assetReference, assetNamespace } = (0, caip_1.fromAssetId)(asset.assetId);
     // For native SUI token, the assetReference is 'slip44:784' but Cetus expects '0x2::sui::SUI'
@@ -45,74 +38,26 @@ const getCoinType = (asset) => {
     return assetReference;
 };
 exports.getCoinType = getCoinType;
-const determineSwapDirection = (pool, sellCoinType, buyCoinType) => {
-    if (pool.coinTypeA === sellCoinType && pool.coinTypeB === buyCoinType) {
-        return true;
-    }
-    if (pool.coinTypeA === buyCoinType && pool.coinTypeB === sellCoinType) {
-        return false;
-    }
-    throw new Error('Pool does not match the swap pair');
-};
-exports.determineSwapDirection = determineSwapDirection;
-const calculateAmountLimit = (estimatedAmount, slippageTolerancePercentageDecimal, isBuyAmount) => {
-    if (!slippageTolerancePercentageDecimal) {
-        return estimatedAmount;
-    }
-    const slippageFactor = (0, utils_1.bn)(1).minus(slippageTolerancePercentageDecimal);
-    if (isBuyAmount) {
-        return (0, utils_1.bnOrZero)(estimatedAmount).times(slippageFactor).toFixed(0);
-    }
-    const maxSlippageFactor = (0, utils_1.bn)(1).plus(slippageTolerancePercentageDecimal);
-    return (0, utils_1.bnOrZero)(estimatedAmount).times(maxSlippageFactor).toFixed(0);
-};
-exports.calculateAmountLimit = calculateAmountLimit;
-const findBestPool = async (sdk, sellCoinType, buyCoinType) => {
-    const pools = await sdk.Pool.getPoolByCoins([sellCoinType, buyCoinType]);
-    if (!pools || pools.length === 0) {
-        return undefined;
-    }
-    const poolWithLiquidity = pools.find(pool => {
-        const hasLiquidity = pool.liquidity && (0, utils_1.bnOrZero)(pool.liquidity).gt(0);
-        return hasLiquidity;
+const findBestRoute = async (client, sellCoinType, buyCoinType, sellAmountCryptoBaseUnit, providers) => {
+    const routerData = await client.findRouters({
+        from: sellCoinType,
+        target: buyCoinType,
+        amount: sellAmountCryptoBaseUnit,
+        byAmountIn: true,
+        ...(providers && { providers }),
     });
-    if (!poolWithLiquidity) {
-        console.warn('[Cetus] No pools with liquidity found for', sellCoinType, buyCoinType, {
-            totalPools: pools.length,
-            pools: pools.map(p => ({ id: p.poolAddress, liquidity: p.liquidity })),
-        });
+    if (!routerData) {
+        console.warn('[Cetus Aggregator] No route found for', sellCoinType, buyCoinType);
+        return undefined;
     }
-    return poolWithLiquidity;
-};
-exports.findBestPool = findBestPool;
-const calculateSwapAmounts = async (sdk, pool, sellAsset, buyAsset, sellAmount) => {
-    const sellCoinType = (0, exports.getCoinType)(sellAsset);
-    const buyCoinType = (0, exports.getCoinType)(buyAsset);
-    const a2b = (0, exports.determineSwapDirection)(pool, sellCoinType, buyCoinType);
-    const decimalsA = pool.coinTypeA === sellCoinType ? sellAsset.precision : buyAsset.precision;
-    const decimalsB = pool.coinTypeA === sellCoinType ? buyAsset.precision : sellAsset.precision;
-    const preSwapParams = {
-        pool,
-        currentSqrtPrice: pool.current_sqrt_price,
-        coinTypeA: pool.coinTypeA,
-        coinTypeB: pool.coinTypeB,
-        decimalsA,
-        decimalsB,
-        a2b,
-        byAmountIn: true,
-        amount: sellAmount,
-    };
-    const preSwapResult = await sdk.Swap.preswap(preSwapParams);
-    if (!preSwapResult) {
+    if (routerData.insufficientLiquidity) {
+        console.warn('[Cetus Aggregator] Insufficient liquidity for', sellCoinType, buyCoinType);
         return undefined;
     }
-    if (preSwapResult.estimatedAmountOut === '0' || preSwapResult.estimatedAmountOut === '') {
+    if (routerData.error) {
+        console.warn('[Cetus Aggregator] Error finding route:', routerData.error);
         return undefined;
     }
-    return {
-        estimatedAmountOut: preSwapResult.estimatedAmountOut,
-        estimatedAmountIn: preSwapResult.estimatedAmountIn,
-        estimatedFeeAmount: preSwapResult.estimatedFeeAmount,
-    };
+    return routerData;
 };
-exports.calculateSwapAmounts = calculateSwapAmounts;
+exports.findBestRoute = findBestRoute;

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

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import type { QuoteResponse, SwapInstructionsResponse } from '@jup-ag/api';
 import type { ChainId } from '@shapeshiftoss/caip';
 import type { solana } from '@shapeshiftoss/chain-adapters';

package/dist/cjs/swappers/MayachainSwapper/generated/generatedTradableAssetMap.json

@@ -21,5 +21,6 @@
     "ETH.USDT-0XDAC17F958D2EE523A2206206994597C13D831EC7": "eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7",
     "ETH.WSTETH-0X7F39C581F595B53C5CB19BD0B3F8DA6C935E2CA0": "eip155:1/erc20:0x7f39c581f595b53c5cb19bd0b3f8da6c935e2ca0",
     "THOR.RUNE": "cosmos:thorchain-1/slip44:931",
+    "ZEC.ZEC": "bip122:00040fe8ec8471911baa1db1266ea15d/slip44:133",
     "MAYA.CACAO": "cosmos:mayachain-mainnet-v1/slip44:931"
 }

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

@@ -5,8 +5,10 @@ const utils_1 = require("../../utils");
 exports.nearIntentsSwapper = {
     executeEvmTransaction: utils_1.executeEvmTransaction,
     executeSolanaTransaction: utils_1.executeSolanaTransaction,
+    executeStarknetTransaction: utils_1.executeStarknetTransaction,
     executeTronTransaction: utils_1.executeTronTransaction,
     executeSuiTransaction: utils_1.executeSuiTransaction,
+    executeNearTransaction: utils_1.executeNearTransaction,
     executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
         return signAndBroadcastTransaction(txToSign);
     },

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

@@ -180,6 +180,74 @@ exports.nearIntentsApi = {
         }
         return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
     },
+    getUnsignedNearTransaction: async ({ stepIndex, tradeQuote, from, assertGetNearChainAdapter, }) => {
+        if (!(0, utils_2.isExecutableTradeQuote)(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = (0, utils_2.getExecutableTradeStep)(tradeQuote, stepIndex);
+        const { accountNumber, sellAsset, nearIntentsSpecific } = step;
+        if (!nearIntentsSpecific)
+            throw new Error('nearIntentsSpecific is required');
+        const adapter = assertGetNearChainAdapter(sellAsset.chainId);
+        const to = nearIntentsSpecific.depositAddress;
+        const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
+        const contractAddress = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
+        return await adapter.buildSendApiTransaction({
+            to,
+            from,
+            value,
+            accountNumber,
+            chainSpecific: { contractAddress },
+        });
+    },
+    getNearTransactionFees: ({ tradeQuote, stepIndex }) => {
+        if (!(0, utils_2.isExecutableTradeQuote)(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = (0, utils_2.getExecutableTradeStep)(tradeQuote, stepIndex);
+        if (!step.feeData.networkFeeCryptoBaseUnit) {
+            throw new Error('Missing network fee in quote');
+        }
+        return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
+    },
+    getUnsignedStarknetTransaction: async ({ stepIndex, tradeQuote, from, assertGetStarknetChainAdapter, }) => {
+        if (!(0, utils_2.isExecutableTradeQuote)(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = (0, utils_2.getExecutableTradeStep)(tradeQuote, stepIndex);
+        const { accountNumber, sellAsset, nearIntentsSpecific } = step;
+        if (!nearIntentsSpecific)
+            throw new Error('nearIntentsSpecific is required');
+        const adapter = assertGetStarknetChainAdapter(sellAsset.chainId);
+        const to = nearIntentsSpecific.depositAddress;
+        const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
+        const tokenContractAddress = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
+        const { fast } = await adapter.getFeeData({
+            to,
+            value,
+            chainSpecific: {
+                from,
+                tokenContractAddress,
+            },
+            sendMax: false,
+        });
+        return adapter.buildSendApiTransaction({
+            from,
+            to,
+            value,
+            accountNumber,
+            chainSpecific: {
+                tokenContractAddress,
+                maxFee: fast.chainSpecific.maxFee,
+            },
+        });
+    },
+    getStarknetTransactionFees: ({ tradeQuote, stepIndex }) => {
+        if (!(0, utils_2.isExecutableTradeQuote)(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = (0, utils_2.getExecutableTradeStep)(tradeQuote, stepIndex);
+        if (!step.feeData.networkFeeCryptoBaseUnit) {
+            throw new Error('Missing network fee in quote');
+        }
+        return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
+    },
     checkTradeStatus: async ({ config, swap }) => {
         const { nearIntentsSpecific } = swap?.metadata ?? {};
         if (!nearIntentsSpecific?.depositAddress) {

package/dist/cjs/swappers/NearIntentsSwapper/swapperApi/getTradeQuote.js

@@ -148,9 +148,14 @@ const getTradeQuote = async (input, deps) => {
                 }
                 case caip_1.CHAIN_NAMESPACE.Tron: {
                     const sellAdapter = deps.assertGetTronChainAdapter(sellAsset.chainId);
+                    const contractAddress = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
                     const feeData = await sellAdapter.getFeeData({
                         to: depositAddress,
                         value: sellAmount,
+                        chainSpecific: {
+                            from: sendAddress,
+                            contractAddress,
+                        },
                     });
                     return { networkFeeCryptoBaseUnit: feeData.fast.txFee };
                 }
@@ -170,6 +175,31 @@ const getTradeQuote = async (input, deps) => {
                     });
                     return { networkFeeCryptoBaseUnit: feeData.fast.txFee };
                 }
+                case caip_1.CHAIN_NAMESPACE.Near: {
+                    const sellAdapter = deps.assertGetNearChainAdapter(sellAsset.chainId);
+                    const feeData = await sellAdapter.getFeeData({
+                        to: depositAddress,
+                        value: sellAmount,
+                        chainSpecific: { from },
+                    });
+                    return { networkFeeCryptoBaseUnit: feeData.fast.txFee };
+                }
+                case caip_1.CHAIN_NAMESPACE.Starknet: {
+                    const sellAdapter = deps.assertGetStarknetChainAdapter(sellAsset.chainId);
+                    const tokenContractAddress = (0, utils_1.isToken)(sellAsset.assetId)
+                        ? (0, caip_1.fromAssetId)(sellAsset.assetId).assetReference
+                        : undefined;
+                    const feeData = await sellAdapter.getFeeData({
+                        to: depositAddress,
+                        value: sellAmount,
+                        chainSpecific: {
+                            from,
+                            tokenContractAddress,
+                        },
+                        sendMax: false,
+                    });
+                    return { networkFeeCryptoBaseUnit: feeData.fast.txFee };
+                }
                 default:
                     throw new Error(`Unsupported chain namespace: ${chainNamespace}`);
             }

package/dist/cjs/swappers/NearIntentsSwapper/swapperApi/getTradeRate.js

@@ -23,14 +23,12 @@ const getTradeRate = async (input, deps) => {
         const originAsset = await (0, helpers_2.assetToNearIntentsAsset)(sellAsset);
         const destinationAsset = await (0, helpers_2.assetToNearIntentsAsset)(buyAsset);
         if (!originAsset) {
-            console.log('[NEAR] Returning error - originAsset not supported');
             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) {
-            console.log('[NEAR] Returning error - destinationAsset not supported');
             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`,
@@ -76,9 +74,31 @@ const getTradeRate = async (input, deps) => {
         const getFeeData = async () => {
             switch (chainNamespace) {
                 case caip_1.CHAIN_NAMESPACE.Evm: {
+                    const sellAdapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+                    const contractAddress = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
+                    const data = chain_adapters_1.evm.getErc20Data(depositAddress, sellAmount, contractAddress);
+                    // For Monad, skip Tenderly and use adapter's getFeeData directly
+                    if (sellAsset.chainId === caip_1.monadChainId) {
+                        try {
+                            const feeData = await sellAdapter.getFeeData({
+                                to: contractAddress ?? depositAddress,
+                                value: (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId) ? sellAmount : '0',
+                                chainSpecific: {
+                                    from: sendAddress || depositAddress,
+                                    contractAddress,
+                                    data: data || '0x',
+                                },
+                                sendMax: false,
+                            });
+                            return feeData.fast.txFee;
+                        }
+                        catch (error) {
+                            console.error('Failed to estimate fees for Monad Near Intents:', error);
+                            return '0';
+                        }
+                    }
+                    // For other EVM chains, use Tenderly simulation
                     try {
-                        const contractAddress = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
-                        const data = chain_adapters_1.evm.getErc20Data(depositAddress, sellAmount, contractAddress);
                         const simulationResult = await (0, tenderly_1.simulateWithStateOverrides)({
                             chainId: sellAsset.chainId,
                             from: (0, viem_1.getAddress)(sendAddress || depositAddress),
@@ -95,7 +115,6 @@ const getTradeRate = async (input, deps) => {
                             return '0';
                         }
                         // Calculate network fee using the simulated gas limit
-                        const sellAdapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
                         const { average } = await sellAdapter.getGasFeeData();
                         const supportsEIP1559 = 'maxFeePerGas' in average;
                         const networkFeeCryptoBaseUnit = chain_adapters_1.evm.calcNetworkFeeCryptoBaseUnit({
@@ -159,9 +178,14 @@ const getTradeRate = async (input, deps) => {
                 case caip_1.CHAIN_NAMESPACE.Tron: {
                     try {
                         const sellAdapter = deps.assertGetTronChainAdapter(sellAsset.chainId);
+                        const contractAddress = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
                         const feeData = await sellAdapter.getFeeData({
                             to: depositAddress,
                             value: sellAmount,
+                            chainSpecific: {
+                                from: sendAddress,
+                                contractAddress,
+                            },
                         });
                         return feeData.fast.txFee;
                     }
@@ -193,6 +217,30 @@ const getTradeRate = async (input, deps) => {
                         return '0';
                     }
                 }
+                case caip_1.CHAIN_NAMESPACE.Starknet: {
+                    try {
+                        const sellAdapter = deps.assertGetStarknetChainAdapter(sellAsset.chainId);
+                        const tokenContractAddress = (0, utils_1.isToken)(sellAsset.assetId)
+                            ? (0, caip_1.fromAssetId)(sellAsset.assetId).assetReference
+                            : undefined;
+                        if (!sendAddress) {
+                            return '0';
+                        }
+                        const feeData = await sellAdapter.getFeeData({
+                            to: depositAddress,
+                            value: sellAmount,
+                            chainSpecific: {
+                                from: sendAddress,
+                                tokenContractAddress,
+                            },
+                            sendMax: false,
+                        });
+                        return feeData.fast.txFee;
+                    }
+                    catch (error) {
+                        return '0';
+                    }
+                }
                 default:
                     return undefined;
             }

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

@@ -1,6 +1,6 @@
 import { KnownChainIds } from '@shapeshiftoss/types';
 export { QuoteRequest } from '@defuse-protocol/one-click-sdk-typescript';
 export type { GetExecutionStatusResponse, QuoteResponse, TokenResponse, } from '@defuse-protocol/one-click-sdk-typescript';
-export declare const nearIntentsSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.GnosisMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BitcoinMainnet, KnownChainIds.DogecoinMainnet, KnownChainIds.SolanaMainnet, KnownChainIds.TronMainnet, KnownChainIds.SuiMainnet];
+export declare const nearIntentsSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.GnosisMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BitcoinMainnet, KnownChainIds.DogecoinMainnet, KnownChainIds.ZcashMainnet, KnownChainIds.SolanaMainnet, KnownChainIds.TronMainnet, KnownChainIds.SuiMainnet, KnownChainIds.StarknetMainnet, KnownChainIds.MonadMainnet, KnownChainIds.NearMainnet];
 export type NearIntentsSupportedChainId = (typeof nearIntentsSupportedChainIds)[number];
 export declare const chainIdToNearIntentsChain: Record<NearIntentsSupportedChainId, string>;

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

@@ -15,9 +15,13 @@ exports.nearIntentsSupportedChainIds = [
     types_1.KnownChainIds.OptimismMainnet,
     types_1.KnownChainIds.BitcoinMainnet,
     types_1.KnownChainIds.DogecoinMainnet,
+    types_1.KnownChainIds.ZcashMainnet,
     types_1.KnownChainIds.SolanaMainnet,
     types_1.KnownChainIds.TronMainnet,
     types_1.KnownChainIds.SuiMainnet,
+    types_1.KnownChainIds.StarknetMainnet,
+    types_1.KnownChainIds.MonadMainnet,
+    types_1.KnownChainIds.NearMainnet,
 ];
 exports.chainIdToNearIntentsChain = {
     [types_1.KnownChainIds.EthereumMainnet]: 'eth',
@@ -30,7 +34,11 @@ exports.chainIdToNearIntentsChain = {
     [types_1.KnownChainIds.OptimismMainnet]: 'op',
     [types_1.KnownChainIds.BitcoinMainnet]: 'btc',
     [types_1.KnownChainIds.DogecoinMainnet]: 'doge',
+    [types_1.KnownChainIds.ZcashMainnet]: 'zec',
     [types_1.KnownChainIds.SolanaMainnet]: 'sol',
     [types_1.KnownChainIds.TronMainnet]: 'tron',
     [types_1.KnownChainIds.SuiMainnet]: 'sui',
+    [types_1.KnownChainIds.StarknetMainnet]: 'starknet',
+    [types_1.KnownChainIds.MonadMainnet]: 'monad',
+    [types_1.KnownChainIds.NearMainnet]: 'near',
 };

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

@@ -28,25 +28,45 @@ const getNearIntentsAsset = ({ nearNetwork, contractAddress, }) => {
     return `nep141:${nearNetwork}-${contractAddress.toLowerCase()}.omft.near`;
 };
 exports.getNearIntentsAsset = getNearIntentsAsset;
-const NEP245_CHAINS = ['bsc', 'pol', 'avax', 'op', 'tron'];
-const TOKEN_LOOKUP_CHAINS = ['sui'];
+const NEP245_CHAINS = ['bsc', 'pol', 'avax', 'op', 'tron', 'monad'];
+const TOKEN_LOOKUP_CHAINS = ['sui', 'starknet'];
+const NEAR_CHAIN = 'near';
+const WNEAR_CONTRACT_ADDRESS = 'wrap.near';
+const isNep245Chain = (chain) => {
+    return NEP245_CHAINS.includes(chain);
+};
+const isTokenLookupChain = (chain) => {
+    return TOKEN_LOOKUP_CHAINS.includes(chain);
+};
 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
+    // NEAR chain requires special handling
+    // Native NEAR maps to wNEAR (wrap.near)
+    if (nearNetwork === NEAR_CHAIN) {
+        const tokens = await oneClickService_1.OneClickService.getTokens();
+        const { assetNamespace, assetReference } = (0, caip_1.fromAssetId)(asset.assetId);
+        const isNativeAsset = assetNamespace === 'slip44';
+        // Native NEAR maps to wNEAR, tokens use their contract address directly
+        const contractAddress = isNativeAsset ? WNEAR_CONTRACT_ADDRESS : assetReference;
+        const match = tokens.find((t) => {
+            if (t.blockchain !== NEAR_CHAIN)
+                return false;
+            return t.contractAddress === contractAddress;
+        });
+        return match?.assetId ?? null;
+    }
+    // NEP-245 chains (BSC, Polygon, Avalanche, Optimism, TRON, Monad), Token lookup chains (Sui, Starknet), 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;
+    const requiresLookup = isNep245Chain(nearNetwork) || isTokenLookupChain(nearNetwork) || asset.chainId === caip_1.solanaChainId;
     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)
+            if (typeof t.blockchain !== 'string' || t.blockchain !== nearNetwork)
                 return false;
             return contractAddress
                 ? t.contractAddress?.toLowerCase() === contractAddress

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

@@ -8,7 +8,7 @@ exports.chainIdToPortalsNetwork = {
     [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',
+    [types_1.KnownChainIds.HyperEvmMainnet]: 'hyperevm',
 };

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

@@ -5,10 +5,13 @@ var __importDefault = (this && this.__importDefault) || function (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 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);
@@ -52,5 +55,93 @@ exports.portalsApi = {
             gasLimit: bignumber_js_1.default.max(feeData.gasLimit, estimatedGas).toFixed(),
         });
     },
-    checkTradeStatus: utils_1.checkEvmSwapStatus,
+    checkTradeStatus: async (input) => {
+        const { txHash, chainId, swap, assertGetEvmChainAdapter, address, fetchIsSmartContractAddressQuery, } = input;
+        const isCrossChain = Boolean(swap && swap.sellAsset.chainId !== swap.buyAsset?.chainId);
+        if (!isCrossChain) {
+            return (0, utils_1.checkEvmSwapStatus)({
+                txHash,
+                chainId,
+                address,
+                assertGetEvmChainAdapter,
+                fetchIsSmartContractAddressQuery,
+            });
+        }
+        const sourceTxStatus = await (0, utils_1.checkEvmSwapStatus)({
+            txHash,
+            chainId,
+            address,
+            assertGetEvmChainAdapter,
+            fetchIsSmartContractAddressQuery,
+        });
+        if (sourceTxStatus.status === unchained_client_1.TxStatus.Pending || sourceTxStatus.status === unchained_client_1.TxStatus.Unknown) {
+            return {
+                status: unchained_client_1.TxStatus.Pending,
+                buyTxHash: undefined,
+                message: 'Source transaction pending',
+            };
+        }
+        if (sourceTxStatus.status === unchained_client_1.TxStatus.Failed) {
+            return sourceTxStatus;
+        }
+        const axelarscanResult = await (0, fetchAxelarscanStatus_1.fetchAxelarscanBridgeStatus)(txHash);
+        if ((axelarscanResult.isErr() || !axelarscanResult.unwrap()) && swap) {
+            const squidResult = await (0, fetchSquidStatus_1.fetchSquidBridgeStatus)(txHash, swap.sellAsset.chainId, swap.buyAsset.chainId);
+            if (squidResult.isOk()) {
+                const squidStatus = squidResult.unwrap();
+                const squidTxStatus = (() => {
+                    switch (squidStatus.status) {
+                        case 'confirmed':
+                            return unchained_client_1.TxStatus.Confirmed;
+                        case 'failed':
+                            return unchained_client_1.TxStatus.Failed;
+                        case 'pending':
+                        default:
+                            return unchained_client_1.TxStatus.Pending;
+                    }
+                })();
+                return {
+                    status: squidTxStatus,
+                    buyTxHash: squidStatus.destinationTxHash,
+                    relayerExplorerTxLink: (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),
+                message: 'Bridge status check failed - track manually',
+            };
+        }
+        const bridgeStatus = axelarscanResult.unwrap();
+        if (!bridgeStatus) {
+            return {
+                status: unchained_client_1.TxStatus.Pending,
+                buyTxHash: undefined,
+                message: 'Cross-chain swap in progress',
+            };
+        }
+        const txStatus = (() => {
+            switch (bridgeStatus.status) {
+                case 'confirmed':
+                    return unchained_client_1.TxStatus.Confirmed;
+                case 'failed':
+                    return unchained_client_1.TxStatus.Failed;
+                case 'pending':
+                default:
+                    return unchained_client_1.TxStatus.Pending;
+            }
+        })();
+        return {
+            status: txStatus,
+            buyTxHash: bridgeStatus.destinationTxHash,
+            relayerExplorerTxLink: (0, fetchAxelarscanStatus_1.getAxelarscanTrackingLink)(txHash),
+            message: txStatus === unchained_client_1.TxStatus.Pending
+                ? 'Bridge in progress'
+                : txStatus === unchained_client_1.TxStatus.Failed
+                    ? bridgeStatus.errorMessage
+                    : undefined,
+        };
+    },
 };