@shapeshiftoss/swapper 17.6.7 → 17.6.9

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

@@ -1,9 +1,11 @@
-import { executeEvmTransaction, executeSolanaTransaction, executeSuiTransaction, executeTronTransaction, } from '../../utils.js';
+import { executeEvmTransaction, executeNearTransaction, executeSolanaTransaction, executeStarknetTransaction, executeSuiTransaction, executeTronTransaction, } from '../../utils.js';
 export const nearIntentsSwapper = {
     executeEvmTransaction,
     executeSolanaTransaction,
+    executeStarknetTransaction,
     executeTronTransaction,
     executeSuiTransaction,
+    executeNearTransaction,
     executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
         return signAndBroadcastTransaction(txToSign);
     },

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

@@ -177,6 +177,74 @@ export const nearIntentsApi = {
         }
         return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
     },
+    getUnsignedNearTransaction: async ({ stepIndex, tradeQuote, from, assertGetNearChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = 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 = contractAddressOrUndefined(sellAsset.assetId);
+        return await adapter.buildSendApiTransaction({
+            to,
+            from,
+            value,
+            accountNumber,
+            chainSpecific: { contractAddress },
+        });
+    },
+    getNearTransactionFees: ({ tradeQuote, stepIndex }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = 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 (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = 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 = 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 (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = 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/esm/swappers/NearIntentsSwapper/swapperApi/getTradeQuote.js

@@ -145,9 +145,14 @@ export const getTradeQuote = async (input, deps) => {
                 }
                 case CHAIN_NAMESPACE.Tron: {
                     const sellAdapter = deps.assertGetTronChainAdapter(sellAsset.chainId);
+                    const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
                     const feeData = await sellAdapter.getFeeData({
                         to: depositAddress,
                         value: sellAmount,
+                        chainSpecific: {
+                            from: sendAddress,
+                            contractAddress,
+                        },
                     });
                     return { networkFeeCryptoBaseUnit: feeData.fast.txFee };
                 }
@@ -167,6 +172,31 @@ export const getTradeQuote = async (input, deps) => {
                     });
                     return { networkFeeCryptoBaseUnit: feeData.fast.txFee };
                 }
+                case 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 CHAIN_NAMESPACE.Starknet: {
+                    const sellAdapter = deps.assertGetStarknetChainAdapter(sellAsset.chainId);
+                    const tokenContractAddress = isToken(sellAsset.assetId)
+                        ? 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/esm/swappers/NearIntentsSwapper/swapperApi/getTradeRate.js

@@ -1,4 +1,4 @@
-import { CHAIN_NAMESPACE, fromAssetId } from '@shapeshiftoss/caip';
+import { CHAIN_NAMESPACE, fromAssetId, monadChainId } from '@shapeshiftoss/caip';
 import { evm } from '@shapeshiftoss/chain-adapters';
 import { bn, bnOrZero, contractAddressOrUndefined, DAO_TREASURY_NEAR, isToken, } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
@@ -20,14 +20,12 @@ export const getTradeRate = async (input, deps) => {
         const originAsset = await assetToNearIntentsAsset(sellAsset);
         const destinationAsset = await assetToNearIntentsAsset(buyAsset);
         if (!originAsset) {
-            console.log('[NEAR] Returning error - originAsset not supported');
             return Err(makeSwapErrorRight({
                 code: 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 Err(makeSwapErrorRight({
                 code: TradeQuoteError.UnsupportedTradePair,
                 message: `Asset ${buyAsset.symbol} on ${buyAsset.networkName || buyAsset.chainId} is not supported by NEAR Intents`,
@@ -73,9 +71,31 @@ export const getTradeRate = async (input, deps) => {
         const getFeeData = async () => {
             switch (chainNamespace) {
                 case CHAIN_NAMESPACE.Evm: {
+                    const sellAdapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+                    const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
+                    const data = evm.getErc20Data(depositAddress, sellAmount, contractAddress);
+                    // For Monad, skip Tenderly and use adapter's getFeeData directly
+                    if (sellAsset.chainId === monadChainId) {
+                        try {
+                            const feeData = await sellAdapter.getFeeData({
+                                to: contractAddress ?? depositAddress,
+                                value: 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 = contractAddressOrUndefined(sellAsset.assetId);
-                        const data = evm.getErc20Data(depositAddress, sellAmount, contractAddress);
                         const simulationResult = await simulateWithStateOverrides({
                             chainId: sellAsset.chainId,
                             from: getAddress(sendAddress || depositAddress),
@@ -92,7 +112,6 @@ export 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 = evm.calcNetworkFeeCryptoBaseUnit({
@@ -156,9 +175,14 @@ export const getTradeRate = async (input, deps) => {
                 case CHAIN_NAMESPACE.Tron: {
                     try {
                         const sellAdapter = deps.assertGetTronChainAdapter(sellAsset.chainId);
+                        const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
                         const feeData = await sellAdapter.getFeeData({
                             to: depositAddress,
                             value: sellAmount,
+                            chainSpecific: {
+                                from: sendAddress,
+                                contractAddress,
+                            },
                         });
                         return feeData.fast.txFee;
                     }
@@ -190,6 +214,30 @@ export const getTradeRate = async (input, deps) => {
                         return '0';
                     }
                 }
+                case CHAIN_NAMESPACE.Starknet: {
+                    try {
+                        const sellAdapter = deps.assertGetStarknetChainAdapter(sellAsset.chainId);
+                        const tokenContractAddress = isToken(sellAsset.assetId)
+                            ? 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/esm/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/esm/swappers/NearIntentsSwapper/types.js

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

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

@@ -1,5 +1,5 @@
 import { ASSOCIATED_PROGRAM_ID } from '@coral-xyz/anchor/dist/cjs/utils/token';
-import { fromAssetId, solanaChainId, suiChainId } from '@shapeshiftoss/caip';
+import { fromAssetId, solanaChainId } from '@shapeshiftoss/caip';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
 import { bnOrZero, isToken } from '@shapeshiftoss/utils';
 import { zeroAddress } from 'viem';
@@ -23,25 +23,45 @@ export const getNearIntentsAsset = ({ nearNetwork, contractAddress, }) => {
     // ERC20 tokens: "nep141:eth-0x{address}.omft.near"
     return `nep141:${nearNetwork}-${contractAddress.toLowerCase()}.omft.near`;
 };
-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);
+};
 export const assetToNearIntentsAsset = async (asset) => {
     const nearNetwork = 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.getTokens();
+        const { assetNamespace, assetReference } = 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 === solanaChainId ||
-        asset.chainId === suiChainId;
+    const requiresLookup = isNep245Chain(nearNetwork) || isTokenLookupChain(nearNetwork) || asset.chainId === solanaChainId;
     if (requiresLookup) {
         const tokens = await OneClickService.getTokens();
         const { assetNamespace, assetReference } = 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/esm/swappers/PortalsSwapper/constants.js

@@ -5,7 +5,7 @@ export const chainIdToPortalsNetwork = {
     [KnownChainIds.OptimismMainnet]: 'optimism',
     [KnownChainIds.BnbSmartChainMainnet]: 'bsc',
     [KnownChainIds.PolygonMainnet]: 'polygon',
-    [KnownChainIds.GnosisMainnet]: 'gnosis',
     [KnownChainIds.ArbitrumMainnet]: 'arbitrum',
     [KnownChainIds.BaseMainnet]: 'base',
+    [KnownChainIds.HyperEvmMainnet]: 'hyperevm',
 };

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

@@ -1,8 +1,11 @@
 import { evm } from '@shapeshiftoss/chain-adapters';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
 import BigNumber from 'bignumber.js';
 import { checkEvmSwapStatus, getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
 import { getPortalsTradeQuote } from './getPortalsTradeQuote/getPortalsTradeQuote.js';
 import { getPortalsTradeRate } from './getPortalsTradeRate/getPortalsTradeRate.js';
+import { fetchAxelarscanBridgeStatus, getAxelarscanTrackingLink, } from './utils/fetchAxelarscanStatus.js';
+import { fetchSquidBridgeStatus, getSquidTrackingLink } from './utils/fetchSquidStatus.js';
 export const portalsApi = {
     getTradeQuote: async (input, { config, assertGetEvmChainAdapter }) => {
         const tradeQuoteResult = await getPortalsTradeQuote(input, assertGetEvmChainAdapter, config);
@@ -46,5 +49,93 @@ export const portalsApi = {
             gasLimit: BigNumber.max(feeData.gasLimit, estimatedGas).toFixed(),
         });
     },
-    checkTradeStatus: 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 checkEvmSwapStatus({
+                txHash,
+                chainId,
+                address,
+                assertGetEvmChainAdapter,
+                fetchIsSmartContractAddressQuery,
+            });
+        }
+        const sourceTxStatus = await checkEvmSwapStatus({
+            txHash,
+            chainId,
+            address,
+            assertGetEvmChainAdapter,
+            fetchIsSmartContractAddressQuery,
+        });
+        if (sourceTxStatus.status === TxStatus.Pending || sourceTxStatus.status === TxStatus.Unknown) {
+            return {
+                status: TxStatus.Pending,
+                buyTxHash: undefined,
+                message: 'Source transaction pending',
+            };
+        }
+        if (sourceTxStatus.status === TxStatus.Failed) {
+            return sourceTxStatus;
+        }
+        const axelarscanResult = await fetchAxelarscanBridgeStatus(txHash);
+        if ((axelarscanResult.isErr() || !axelarscanResult.unwrap()) && swap) {
+            const squidResult = await fetchSquidBridgeStatus(txHash, swap.sellAsset.chainId, swap.buyAsset.chainId);
+            if (squidResult.isOk()) {
+                const squidStatus = squidResult.unwrap();
+                const squidTxStatus = (() => {
+                    switch (squidStatus.status) {
+                        case 'confirmed':
+                            return TxStatus.Confirmed;
+                        case 'failed':
+                            return TxStatus.Failed;
+                        case 'pending':
+                        default:
+                            return TxStatus.Pending;
+                    }
+                })();
+                return {
+                    status: squidTxStatus,
+                    buyTxHash: squidStatus.destinationTxHash,
+                    relayerExplorerTxLink: getSquidTrackingLink(txHash, squidStatus, swap.sellAsset.explorerTxLink, swap.buyAsset.explorerTxLink),
+                    message: squidTxStatus === TxStatus.Pending ? 'Cross-chain swap in progress' : undefined,
+                };
+            }
+            return {
+                status: TxStatus.Pending,
+                buyTxHash: undefined,
+                relayerExplorerTxLink: getAxelarscanTrackingLink(txHash),
+                message: 'Bridge status check failed - track manually',
+            };
+        }
+        const bridgeStatus = axelarscanResult.unwrap();
+        if (!bridgeStatus) {
+            return {
+                status: TxStatus.Pending,
+                buyTxHash: undefined,
+                message: 'Cross-chain swap in progress',
+            };
+        }
+        const txStatus = (() => {
+            switch (bridgeStatus.status) {
+                case 'confirmed':
+                    return TxStatus.Confirmed;
+                case 'failed':
+                    return TxStatus.Failed;
+                case 'pending':
+                default:
+                    return TxStatus.Pending;
+            }
+        })();
+        return {
+            status: txStatus,
+            buyTxHash: bridgeStatus.destinationTxHash,
+            relayerExplorerTxLink: getAxelarscanTrackingLink(txHash),
+            message: txStatus === TxStatus.Pending
+                ? 'Bridge in progress'
+                : txStatus === TxStatus.Failed
+                    ? bridgeStatus.errorMessage
+                    : undefined,
+        };
+    },
 };

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

@@ -9,7 +9,7 @@ import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
 import { getTreasuryAddressFromChainId, isNativeEvmAsset } from '../../utils/helpers/helpers.js';
 import { chainIdToPortalsNetwork } from '../constants.js';
 import { fetchPortalsTradeOrder, PortalsError } from '../utils/fetchPortalsTradeOrder.js';
-import { isSupportedChainId } from '../utils/helpers.js';
+import { getPortalsRouterAddressByChainId, isSupportedChainId } from '../utils/helpers.js';
 export async function getPortalsTradeQuote(input, assertGetEvmChainAdapter, swapperConfig) {
     const { sellAsset, buyAsset, sendAddress, accountNumber, affiliateBps, chainId, supportsEIP1559, sellAmountIncludingProtocolFeesCryptoBaseUnit, } = input;
     const sellAssetChainId = sellAsset.chainId;
@@ -25,16 +25,10 @@ export async function getPortalsTradeQuote(input, assertGetEvmChainAdapter, swap
         return Err(makeSwapErrorRight({
             message: `unsupported chainId`,
             code: TradeQuoteError.UnsupportedChain,
-            details: { chainId: sellAsset.chainId },
-        }));
-    }
-    if (sellAssetChainId !== buyAssetChainId) {
-        return Err(makeSwapErrorRight({
-            message: `cross-chain not supported - both assets must be on chainId ${sellAsset.chainId}`,
-            code: TradeQuoteError.CrossChainNotSupported,
-            details: { buyAsset, sellAsset },
+            details: { chainId: buyAsset.chainId },
         }));
     }
+    const isCrossChain = sellAssetChainId !== buyAssetChainId;
     // Not a decimal percentage, just a good ol' percentage e.g 1 for 1%
     const affiliateBpsPercentage = convertBasisPointsToDecimalPercentage(affiliateBps)
         .times(100)
@@ -46,12 +40,20 @@ export async function getPortalsTradeQuote(input, assertGetEvmChainAdapter, swap
             .toNumber();
     if (!sendAddress)
         return Err(makeSwapErrorRight({ message: 'missing sendAddress' }));
-    const portalsNetwork = chainIdToPortalsNetwork[chainId];
-    if (!portalsNetwork) {
+    const sellPortalsNetwork = chainIdToPortalsNetwork[sellAssetChainId];
+    const buyPortalsNetwork = chainIdToPortalsNetwork[buyAssetChainId];
+    if (!sellPortalsNetwork) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported ChainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAssetChainId },
+        }));
+    }
+    if (!buyPortalsNetwork) {
         return Err(makeSwapErrorRight({
             message: `unsupported ChainId`,
             code: TradeQuoteError.UnsupportedChain,
-            details: { chainId: input.chainId },
+            details: { chainId: buyAssetChainId },
         }));
     }
     const sellAssetAddress = isNativeEvmAsset(sellAsset.assetId)
@@ -60,8 +62,8 @@ export async function getPortalsTradeQuote(input, assertGetEvmChainAdapter, swap
     const buyAssetAddress = isNativeEvmAsset(buyAsset.assetId)
         ? zeroAddress
         : fromAssetId(buyAsset.assetId).assetReference;
-    const inputToken = `${portalsNetwork}:${sellAssetAddress}`;
-    const outputToken = `${portalsNetwork}:${buyAssetAddress}`;
+    const inputToken = `${sellPortalsNetwork}:${sellAssetAddress}`;
+    const outputToken = `${buyPortalsNetwork}:${buyAssetAddress}`;
     try {
         const maybePortalsTradeOrderResponse = await fetchPortalsTradeOrder({
             sender: sendAddress,
@@ -127,7 +129,9 @@ export async function getPortalsTradeQuote(input, assertGetEvmChainAdapter, swap
         if (maybePortalsTradeOrderResponse.isErr())
             return Err(maybePortalsTradeOrderResponse.unwrapErr());
         const portalsTradeOrderResponse = maybePortalsTradeOrderResponse.unwrap();
-        const { context: { orderId, outputAmount: buyAmountAfterFeesCryptoBaseUnit, minOutputAmount, target: allowanceContract, feeAmount, gasLimit, feeToken, }, tx, } = portalsTradeOrderResponse;
+        const { context: { orderId, outputAmount, minOutputAmount, target, feeAmount, gasLimit, feeToken }, tx, } = portalsTradeOrderResponse;
+        const allowanceContract = isCrossChain ? target : getPortalsRouterAddressByChainId(chainId);
+        const buyAmountAfterFeesCryptoBaseUnit = isCrossChain ? minOutputAmount : outputAmount;
         const protocolFeeAsset = feeToken === inputToken ? sellAsset : buyAsset;
         if (!tx)
             throw new Error('Portals Tx simulation failed upstream');
@@ -186,9 +190,17 @@ export async function getPortalsTradeQuote(input, assertGetEvmChainAdapter, swap
                         },
                     },
                     source: SwapperName.Portals,
-                    // Assume instant execution since this is a same-chain AMM Tx which will happen within the same block
-                    estimatedExecutionTimeMs: 0,
-                    portalsTransactionMetadata: tx,
+                    estimatedExecutionTimeMs: isCrossChain ? 300000 : 0,
+                    portalsTransactionMetadata: {
+                        ...tx,
+                        isCrossChain,
+                        buyAssetChainId: isCrossChain ? buyAssetChainId : undefined,
+                        expiry: portalsTradeOrderResponse.context.expiry
+                            ? Number(portalsTradeOrderResponse.context.expiry)
+                            : undefined,
+                        steps: portalsTradeOrderResponse.context.steps,
+                        route: portalsTradeOrderResponse.context.route,
+                    },
                 },
             ],
         };

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

@@ -31,22 +31,24 @@ export async function getPortalsTradeRate(input, assertGetEvmChainAdapter, swapp
             details: { chainId: sellAsset.chainId },
         }));
     }
-    if (sellAssetChainId !== buyAssetChainId) {
-        return Err(makeSwapErrorRight({
-            message: `cross-chain not supported - both assets must be on chainId ${sellAsset.chainId}`,
-            code: TradeQuoteError.CrossChainNotSupported,
-            details: { buyAsset, sellAsset },
-        }));
-    }
+    const isCrossChain = sellAssetChainId !== buyAssetChainId;
     try {
         if (!isSupportedChainId(chainId))
             throw new Error(`Unsupported chainId ${sellAsset.chainId}`);
-        const portalsNetwork = chainIdToPortalsNetwork[chainId];
-        if (!portalsNetwork) {
+        const sellPortalsNetwork = chainIdToPortalsNetwork[sellAssetChainId];
+        const buyPortalsNetwork = chainIdToPortalsNetwork[buyAssetChainId];
+        if (!sellPortalsNetwork) {
+            return Err(makeSwapErrorRight({
+                message: `unsupported ChainId`,
+                code: TradeQuoteError.UnsupportedChain,
+                details: { chainId: sellAssetChainId },
+            }));
+        }
+        if (!buyPortalsNetwork) {
             return Err(makeSwapErrorRight({
                 message: `unsupported ChainId`,
                 code: TradeQuoteError.UnsupportedChain,
-                details: { chainId: input.chainId },
+                details: { chainId: buyAssetChainId },
             }));
         }
         const sellAssetAddress = isNativeEvmAsset(sellAsset.assetId)
@@ -55,8 +57,8 @@ export async function getPortalsTradeRate(input, assertGetEvmChainAdapter, swapp
         const buyAssetAddress = isNativeEvmAsset(buyAsset.assetId)
             ? zeroAddress
             : fromAssetId(buyAsset.assetId).assetReference;
-        const inputToken = `${portalsNetwork}:${sellAssetAddress}`;
-        const outputToken = `${portalsNetwork}:${buyAssetAddress}`;
+        const inputToken = `${sellPortalsNetwork}:${sellAssetAddress}`;
+        const outputToken = `${buyPortalsNetwork}:${buyAssetAddress}`;
         const userSlippageTolerancePercentageDecimalOrDefault = input.slippageTolerancePercentageDecimal
             ? bnOrZero(input.slippageTolerancePercentageDecimal).times(100).toNumber()
             : bnOrZero(getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Portals))
@@ -86,15 +88,18 @@ export async function getPortalsTradeRate(input, assertGetEvmChainAdapter, swapp
             throw new Error('Portals quote response missing transaction data');
         }
         const { context, tx } = quoteResponse;
-        // Use outputAmount from context, not estimate
-        const buyAmountAfterFeesCryptoBaseUnit = context.outputAmount;
+        const buyAmountAfterFeesCryptoBaseUnit = isCrossChain
+            ? context.minOutputAmount
+            : context.outputAmount;
         const inputOutputRate = getInputOutputRate({
             sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
             buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
             sellAsset,
             buyAsset,
         });
-        const allowanceContract = getPortalsRouterAddressByChainId(chainId);
+        const allowanceContract = isCrossChain
+            ? context.target
+            : 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(context.outputAmount)
@@ -150,8 +155,7 @@ export async function getPortalsTradeRate(input, assertGetEvmChainAdapter, swapp
             swapperName: SwapperName.Portals,
             steps: [
                 {
-                    // Assume instant execution since this is a same-chain AMM Tx which will happen within the same block
-                    estimatedExecutionTimeMs: 0,
+                    estimatedExecutionTimeMs: isCrossChain ? 300000 : 0,
                     allowanceContract,
                     accountNumber,
                     rate: inputOutputRate,

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

@@ -9,4 +9,5 @@ export const PortalsSupportedChainIds = [
     KnownChainIds.OptimismMainnet,
     KnownChainIds.GnosisMainnet,
     KnownChainIds.BaseMainnet,
+    KnownChainIds.HyperEvmMainnet,
 ];

package/dist/esm/swappers/PortalsSwapper/utils/fetchAxelarscanStatus.d.ts

@@ -0,0 +1,9 @@
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types.js';
+export type AxelarscanBridgeStatus = {
+    status: 'pending' | 'confirmed' | 'failed';
+    destinationTxHash?: string;
+    errorMessage?: string;
+};
+export declare const fetchAxelarscanBridgeStatus: (sourceTxHash: string) => Promise<Result<AxelarscanBridgeStatus | undefined, SwapErrorRight>>;
+export declare const getAxelarscanTrackingLink: (sourceTxHash: string) => string;