@shapeshiftoss/swapper 17.6.7 → 17.6.9

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

@@ -28,16 +28,10 @@ async function getPortalsTradeQuote(input, assertGetEvmChainAdapter, swapperConf
         return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
             message: `unsupported chainId`,
             code: types_1.TradeQuoteError.UnsupportedChain,
-            details: { chainId: sellAsset.chainId },
-        }));
-    }
-    if (sellAssetChainId !== buyAssetChainId) {
-        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
-            message: `cross-chain not supported - both assets must be on chainId ${sellAsset.chainId}`,
-            code: types_1.TradeQuoteError.CrossChainNotSupported,
-            details: { buyAsset, sellAsset },
+            details: { chainId: buyAsset.chainId },
         }));
     }
+    const isCrossChain = sellAssetChainId !== buyAssetChainId;
     // Not a decimal percentage, just a good ol' percentage e.g 1 for 1%
     const affiliateBpsPercentage = (0, utils_1.convertBasisPointsToDecimalPercentage)(affiliateBps)
         .times(100)
@@ -49,12 +43,20 @@ async function getPortalsTradeQuote(input, assertGetEvmChainAdapter, swapperConf
             .toNumber();
     if (!sendAddress)
         return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({ message: 'missing sendAddress' }));
-    const portalsNetwork = constants_1.chainIdToPortalsNetwork[chainId];
-    if (!portalsNetwork) {
+    const sellPortalsNetwork = constants_1.chainIdToPortalsNetwork[sellAssetChainId];
+    const buyPortalsNetwork = constants_1.chainIdToPortalsNetwork[buyAssetChainId];
+    if (!sellPortalsNetwork) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `unsupported ChainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAssetChainId },
+        }));
+    }
+    if (!buyPortalsNetwork) {
         return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
             message: `unsupported ChainId`,
             code: types_1.TradeQuoteError.UnsupportedChain,
-            details: { chainId: input.chainId },
+            details: { chainId: buyAssetChainId },
         }));
     }
     const sellAssetAddress = (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId)
@@ -63,8 +65,8 @@ async function getPortalsTradeQuote(input, assertGetEvmChainAdapter, swapperConf
     const buyAssetAddress = (0, helpers_1.isNativeEvmAsset)(buyAsset.assetId)
         ? viem_1.zeroAddress
         : (0, caip_1.fromAssetId)(buyAsset.assetId).assetReference;
-    const inputToken = `${portalsNetwork}:${sellAssetAddress}`;
-    const outputToken = `${portalsNetwork}:${buyAssetAddress}`;
+    const inputToken = `${sellPortalsNetwork}:${sellAssetAddress}`;
+    const outputToken = `${buyPortalsNetwork}:${buyAssetAddress}`;
     try {
         const maybePortalsTradeOrderResponse = await (0, fetchPortalsTradeOrder_1.fetchPortalsTradeOrder)({
             sender: sendAddress,
@@ -130,7 +132,9 @@ async function getPortalsTradeQuote(input, assertGetEvmChainAdapter, swapperConf
         if (maybePortalsTradeOrderResponse.isErr())
             return (0, monads_1.Err)(maybePortalsTradeOrderResponse.unwrapErr());
         const portalsTradeOrderResponse = maybePortalsTradeOrderResponse.unwrap();
-        const { context: { orderId, outputAmount: buyAmountAfterFeesCryptoBaseUnit, minOutputAmount, target: allowanceContract, feeAmount, gasLimit, feeToken, }, tx, } = portalsTradeOrderResponse;
+        const { context: { orderId, outputAmount, minOutputAmount, target, feeAmount, gasLimit, feeToken }, tx, } = portalsTradeOrderResponse;
+        const allowanceContract = isCrossChain ? target : (0, helpers_2.getPortalsRouterAddressByChainId)(chainId);
+        const buyAmountAfterFeesCryptoBaseUnit = isCrossChain ? minOutputAmount : outputAmount;
         const protocolFeeAsset = feeToken === inputToken ? sellAsset : buyAsset;
         if (!tx)
             throw new Error('Portals Tx simulation failed upstream');
@@ -189,9 +193,17 @@ async function getPortalsTradeQuote(input, assertGetEvmChainAdapter, swapperConf
                         },
                     },
                     source: types_1.SwapperName.Portals,
-                    // Assume instant execution since this is a same-chain AMM Tx which will happen within the same block
-                    estimatedExecutionTimeMs: 0,
-                    portalsTransactionMetadata: tx,
+                    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/cjs/swappers/PortalsSwapper/getPortalsTradeRate/getPortalsTradeRate.js

@@ -34,22 +34,24 @@ async function getPortalsTradeRate(input, assertGetEvmChainAdapter, swapperConfi
             details: { chainId: sellAsset.chainId },
         }));
     }
-    if (sellAssetChainId !== buyAssetChainId) {
-        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
-            message: `cross-chain not supported - both assets must be on chainId ${sellAsset.chainId}`,
-            code: types_1.TradeQuoteError.CrossChainNotSupported,
-            details: { buyAsset, sellAsset },
-        }));
-    }
+    const isCrossChain = sellAssetChainId !== buyAssetChainId;
     try {
         if (!(0, helpers_2.isSupportedChainId)(chainId))
             throw new Error(`Unsupported chainId ${sellAsset.chainId}`);
-        const portalsNetwork = constants_1.chainIdToPortalsNetwork[chainId];
-        if (!portalsNetwork) {
+        const sellPortalsNetwork = constants_1.chainIdToPortalsNetwork[sellAssetChainId];
+        const buyPortalsNetwork = constants_1.chainIdToPortalsNetwork[buyAssetChainId];
+        if (!sellPortalsNetwork) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: `unsupported ChainId`,
+                code: types_1.TradeQuoteError.UnsupportedChain,
+                details: { chainId: sellAssetChainId },
+            }));
+        }
+        if (!buyPortalsNetwork) {
             return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
                 message: `unsupported ChainId`,
                 code: types_1.TradeQuoteError.UnsupportedChain,
-                details: { chainId: input.chainId },
+                details: { chainId: buyAssetChainId },
             }));
         }
         const sellAssetAddress = (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId)
@@ -58,8 +60,8 @@ async function getPortalsTradeRate(input, assertGetEvmChainAdapter, swapperConfi
         const buyAssetAddress = (0, helpers_1.isNativeEvmAsset)(buyAsset.assetId)
             ? viem_1.zeroAddress
             : (0, caip_1.fromAssetId)(buyAsset.assetId).assetReference;
-        const inputToken = `${portalsNetwork}:${sellAssetAddress}`;
-        const outputToken = `${portalsNetwork}:${buyAssetAddress}`;
+        const inputToken = `${sellPortalsNetwork}:${sellAssetAddress}`;
+        const outputToken = `${buyPortalsNetwork}:${buyAssetAddress}`;
         const userSlippageTolerancePercentageDecimalOrDefault = input.slippageTolerancePercentageDecimal
             ? (0, utils_1.bnOrZero)(input.slippageTolerancePercentageDecimal).times(100).toNumber()
             : (0, utils_1.bnOrZero)((0, __1.getDefaultSlippageDecimalPercentageForSwapper)(types_1.SwapperName.Portals))
@@ -89,15 +91,18 @@ async function getPortalsTradeRate(input, assertGetEvmChainAdapter, swapperConfi
             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 = (0, utils_2.getInputOutputRate)({
             sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
             buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
             sellAsset,
             buyAsset,
         });
-        const allowanceContract = (0, helpers_2.getPortalsRouterAddressByChainId)(chainId);
+        const allowanceContract = isCrossChain
+            ? context.target
+            : (0, helpers_2.getPortalsRouterAddressByChainId)(chainId);
         // Don't use Portals' slippageTolerancePercentage field (it's a price indicator, not actual buffer)
         // Instead, calculate the actual buffer Portals applied from the amounts
         const actualBufferDecimal = (0, utils_1.bnOrZero)(context.outputAmount)
@@ -153,8 +158,7 @@ async function getPortalsTradeRate(input, assertGetEvmChainAdapter, swapperConfi
             swapperName: types_1.SwapperName.Portals,
             steps: [
                 {
-                    // Assume instant execution since this is a same-chain AMM Tx which will happen within the same block
-                    estimatedExecutionTimeMs: 0,
+                    estimatedExecutionTimeMs: isCrossChain ? 300000 : 0,
                     allowanceContract,
                     accountNumber,
                     rate: inputOutputRate,

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

@@ -12,4 +12,5 @@ exports.PortalsSupportedChainIds = [
     types_1.KnownChainIds.OptimismMainnet,
     types_1.KnownChainIds.GnosisMainnet,
     types_1.KnownChainIds.BaseMainnet,
+    types_1.KnownChainIds.HyperEvmMainnet,
 ];

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

@@ -0,0 +1,9 @@
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types';
+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;

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAxelarscanTrackingLink = exports.fetchAxelarscanBridgeStatus = void 0;
+const monads_1 = require("@sniptt/monads");
+const utils_1 = require("../../../utils");
+const fetchAxelarscanBridgeStatus = async (sourceTxHash) => {
+    try {
+        const response = await fetch(`https://api.axelarscan.io/gmp/searchGMP?txHash=${sourceTxHash}`);
+        if (!response.ok) {
+            return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+                message: `Axelarscan API error: ${response.statusText}`,
+            }));
+        }
+        const data = await response.json();
+        if (!data.data || data.data.length === 0) {
+            return (0, monads_1.Ok)(undefined);
+        }
+        const bridgeData = data.data[0];
+        const destinationTxHash = bridgeData.call?.transaction_hash ||
+            bridgeData.executed?.transaction_hash ||
+            bridgeData.express_executed?.transactionHash;
+        const isCompleted = bridgeData.status === 'executed' ||
+            bridgeData.status === 'destination_executed' ||
+            bridgeData.status === 'express_executed' ||
+            bridgeData.simplified_status === 'received' ||
+            !!destinationTxHash;
+        if (isCompleted) {
+            return (0, monads_1.Ok)({
+                status: 'confirmed',
+                destinationTxHash,
+            });
+        }
+        if (bridgeData.status === 'error') {
+            return (0, monads_1.Ok)({
+                status: 'failed',
+                errorMessage: bridgeData.error?.message || 'Bridge failed',
+            });
+        }
+        return (0, monads_1.Ok)({
+            status: 'pending',
+        });
+    }
+    catch (error) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: 'Failed to fetch Axelarscan bridge status',
+            cause: error,
+        }));
+    }
+};
+exports.fetchAxelarscanBridgeStatus = fetchAxelarscanBridgeStatus;
+const getAxelarscanTrackingLink = (sourceTxHash) => `https://axelarscan.io/gmp/${sourceTxHash}`;
+exports.getAxelarscanTrackingLink = getAxelarscanTrackingLink;

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

@@ -37,6 +37,7 @@ type PortalsTradeOrderResponse = {
         route: string[];
         routeHash: string;
         steps: string[];
+        expiry?: string;
         gasLimit?: string;
         feeToken?: string;
         feeAmount?: string;

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

@@ -0,0 +1,9 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types';
+export type SquidBridgeStatus = {
+    status: 'pending' | 'confirmed' | 'failed';
+    destinationTxHash?: string;
+};
+export declare const fetchSquidBridgeStatus: (sourceTxHash: string, sourceChainId: ChainId, destinationChainId: ChainId) => Promise<Result<SquidBridgeStatus, SwapErrorRight>>;
+export declare const getSquidTrackingLink: (sourceTxHash: string, squidStatus: SquidBridgeStatus, sellAssetExplorerTxLink: string, buyAssetExplorerTxLink: string) => string;

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSquidTrackingLink = exports.fetchSquidBridgeStatus = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const monads_1 = require("@sniptt/monads");
+const utils_1 = require("../../../utils");
+const fetchSquidBridgeStatus = async (sourceTxHash, sourceChainId, destinationChainId) => {
+    try {
+        const fromChain = (0, caip_1.fromChainId)(sourceChainId).chainReference;
+        const toChain = (0, caip_1.fromChainId)(destinationChainId).chainReference;
+        const url = new URL('https://v2.api.squidrouter.com/v2/status');
+        url.searchParams.set('transactionId', sourceTxHash);
+        url.searchParams.set('fromChainId', fromChain);
+        url.searchParams.set('toChainId', toChain);
+        const response = await fetch(url.toString(), {
+            headers: {
+                'x-integrator-id': 'squid-swap-widget',
+            },
+        });
+        if (!response.ok) {
+            return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+                message: `Squid API error: ${response.statusText}`,
+            }));
+        }
+        const data = await response.json();
+        const destinationTxHash = data.toChain?.transactionId;
+        if (data.squidTransactionStatus === 'success') {
+            return (0, monads_1.Ok)({
+                status: 'confirmed',
+                destinationTxHash,
+            });
+        }
+        if (data.squidTransactionStatus === 'partial_success' ||
+            data.squidTransactionStatus === 'needs_gas') {
+            return (0, monads_1.Ok)({
+                status: 'failed',
+            });
+        }
+        return (0, monads_1.Ok)({
+            status: 'pending',
+        });
+    }
+    catch (error) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: 'Failed to fetch Squid bridge status',
+            cause: error,
+        }));
+    }
+};
+exports.fetchSquidBridgeStatus = fetchSquidBridgeStatus;
+const getSquidTrackingLink = (sourceTxHash, squidStatus, sellAssetExplorerTxLink, buyAssetExplorerTxLink) => {
+    if (squidStatus.status === 'confirmed' && squidStatus.destinationTxHash) {
+        return `${buyAssetExplorerTxLink}${squidStatus.destinationTxHash}`;
+    }
+    return `${sellAssetExplorerTxLink}${sourceTxHash}`;
+};
+exports.getSquidTrackingLink = getSquidTrackingLink;

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

@@ -25,6 +25,9 @@ exports.chainIdToRelayChainId = {
     [caip_1.bscChainId]: chains_1.bsc.id,
     [caip_1.tronChainId]: 728126428,
     [caip_1.monadChainId]: chains_1.monad.id,
+    [caip_1.hyperEvmChainId]: chains_1.hyperEvm.id,
+    [caip_1.plasmaChainId]: chains_1.plasma.id,
+    [caip_1.katanaChainId]: chains_1.katana.id,
 };
 var RelayStatusMessage;
 (function (RelayStatusMessage) {

package/dist/cjs/swappers/RelaySwapper/utils/fetchRelayTrade.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchRelayTrade = void 0;
 const relayService_1 = require("./relayService");
 const fetchRelayTrade = async (params, config) => {
-    return await relayService_1.relayService.post(`${config.VITE_RELAY_API_URL}/quote`, params);
+    return await relayService_1.relayService.post(`${config.VITE_RELAY_API_URL}/quote/v2`, params);
 };
 exports.fetchRelayTrade = fetchRelayTrade;

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

@@ -359,6 +359,10 @@ async function getTrade({ input, deps, relayChainMap, }) {
                         data: (selectedItem.data.data ?? '0x'),
                         value: selectedItem.data.value ?? '0',
                         sellAsset,
+                        // Pass Relay's gas limit to Tenderly for Monad as tenderly return crazy gas
+                        gas: selectedItem.data.gas && sellAsset.chainId === caip_1.monadChainId
+                            ? Number(selectedItem.data.gas)
+                            : undefined,
                     }, {
                         apiKey: deps.config.VITE_TENDERLY_API_KEY,
                         accountSlug: deps.config.VITE_TENDERLY_ACCOUNT_SLUG,
@@ -420,7 +424,8 @@ async function getTrade({ input, deps, relayChainMap, }) {
                     relayTransactionMetadata: {
                         from: sendAddress,
                         to: selectedItem.data?.to,
-                        value: selectedItem.data?.value,
+                        // v2 API may return value as undefined or empty object for ERC-20 swaps - default to '0'
+                        value: typeof selectedItem.data?.value === 'string' ? selectedItem.data.value : '0',
                         data: selectedItem.data?.data,
                         // gas is not documented in the relay docs but refers to gasLimit
                         gasLimit: selectedItem.data?.gas,
@@ -442,6 +447,16 @@ async function getTrade({ input, deps, relayChainMap, }) {
                     },
                 };
             }
+            if ((0, types_2.isRelayQuoteTronItemData)(selectedItem.data)) {
+                return {
+                    allowanceContract: '',
+                    solanaTransactionMetadata: undefined,
+                    relayTransactionMetadata: {
+                        relayId: quote.steps[0].requestId,
+                        to: selectedItem.data?.parameter?.contract_address,
+                    },
+                };
+            }
             throw new Error('Relay quote step contains no data');
         })();
         return {

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

@@ -77,6 +77,11 @@ const relayTokenToAssetId = (relayToken) => {
                     assetReference: caip_1.ASSET_REFERENCE.Base,
                     assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
                 };
+            case caip_1.CHAIN_REFERENCE.BnbSmartChainMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.BnbSmartChain,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
             case caip_1.CHAIN_REFERENCE.BitcoinMainnet:
                 return {
                     assetReference: caip_1.ASSET_REFERENCE.Bitcoin,
@@ -97,6 +102,21 @@ const relayTokenToAssetId = (relayToken) => {
                     assetReference: caip_1.ASSET_REFERENCE.Monad,
                     assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
                 };
+            case caip_1.CHAIN_REFERENCE.HyperEvmMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.HyperEvm,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.PlasmaMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.Plasma,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.KatanaMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.Katana,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
             default:
                 throw Error(`chainId '${relayToken.chainId}' not supported`);
         }

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

@@ -104,8 +104,16 @@ export type RelayQuoteSolanaItemData = {
     instructions: RelaySolanaInstruction[];
     addressLookupTableAddresses: string[];
 };
+export type RelayQuoteTronItemData = {
+    type?: string;
+    parameter?: {
+        owner_address?: string;
+        contract_address?: string;
+        data?: string;
+    };
+};
 export type RelayQuoteItem = {
-    data?: RelayQuoteEvmItemData | RelayQuoteUtxoItemData | RelayQuoteSolanaItemData;
+    data?: RelayQuoteEvmItemData | RelayQuoteUtxoItemData | RelayQuoteSolanaItemData | RelayQuoteTronItemData;
 };
 export type RelayQuoteStep = {
     id: string;
@@ -117,9 +125,10 @@ export type RelayQuote = {
     details: QuoteDetails;
     steps: RelayQuoteStep[];
 };
-export declare const isRelayQuoteUtxoItemData: (item: RelayQuoteUtxoItemData | RelayQuoteEvmItemData | RelayQuoteSolanaItemData) => item is RelayQuoteUtxoItemData;
-export declare const isRelayQuoteEvmItemData: (item: RelayQuoteUtxoItemData | RelayQuoteEvmItemData | RelayQuoteSolanaItemData) => item is RelayQuoteEvmItemData;
-export declare const isRelayQuoteSolanaItemData: (item: RelayQuoteUtxoItemData | RelayQuoteEvmItemData | RelayQuoteSolanaItemData) => item is RelayQuoteSolanaItemData;
+export declare const isRelayQuoteUtxoItemData: (item: RelayQuoteUtxoItemData | RelayQuoteEvmItemData | RelayQuoteSolanaItemData | RelayQuoteTronItemData) => item is RelayQuoteUtxoItemData;
+export declare const isRelayQuoteEvmItemData: (item: RelayQuoteUtxoItemData | RelayQuoteEvmItemData | RelayQuoteSolanaItemData | RelayQuoteTronItemData) => item is RelayQuoteEvmItemData;
+export declare const isRelayQuoteSolanaItemData: (item: RelayQuoteUtxoItemData | RelayQuoteEvmItemData | RelayQuoteSolanaItemData | RelayQuoteTronItemData) => item is RelayQuoteSolanaItemData;
+export declare const isRelayQuoteTronItemData: (item: RelayQuoteUtxoItemData | RelayQuoteEvmItemData | RelayQuoteSolanaItemData | RelayQuoteTronItemData) => item is RelayQuoteTronItemData;
 export type RelaySolanaInstruction = {
     keys: {
         pubkey: string;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRelayError = exports.RelayErrorCode = exports.isRelayQuoteSolanaItemData = exports.isRelayQuoteEvmItemData = exports.isRelayQuoteUtxoItemData = void 0;
+exports.isRelayError = exports.RelayErrorCode = exports.isRelayQuoteTronItemData = exports.isRelayQuoteSolanaItemData = exports.isRelayQuoteEvmItemData = exports.isRelayQuoteUtxoItemData = void 0;
 const isRelayQuoteUtxoItemData = (item) => {
     return 'psbt' in item;
 };
@@ -13,6 +13,10 @@ const isRelayQuoteSolanaItemData = (item) => {
     return 'instructions' in item;
 };
 exports.isRelayQuoteSolanaItemData = isRelayQuoteSolanaItemData;
+const isRelayQuoteTronItemData = (item) => {
+    return 'type' in item && 'parameter' in item;
+};
+exports.isRelayQuoteTronItemData = isRelayQuoteTronItemData;
 var RelayErrorCode;
 (function (RelayErrorCode) {
     RelayErrorCode["AmountTooLow"] = "AMOUNT_TOO_LOW";

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

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

package/dist/cjs/swappers/SunioSwapper/SunioSwapper.js

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

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

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

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

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sunioApi = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const unchained_client_1 = require("@shapeshiftoss/unchained-client");
+const tronweb_1 = require("tronweb");
+const getTronTransactionFees_1 = require("../../tron-utils/getTronTransactionFees");
+const utils_1 = require("../../utils");
+const getSunioTradeQuote_1 = require("./getSunioTradeQuote/getSunioTradeQuote");
+const getSunioTradeRate_1 = require("./getSunioTradeRate/getSunioTradeRate");
+const buildSwapRouteParameters_1 = require("./utils/buildSwapRouteParameters");
+const constants_1 = require("./utils/constants");
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+const convertAddressesToEvmFormat = (value) => {
+    if (Array.isArray(value)) {
+        return value.map(v => convertAddressesToEvmFormat(v));
+    }
+    if (typeof value === 'string' && value.startsWith('T') && tronweb_1.TronWeb.isAddress(value)) {
+        const hex = tronweb_1.TronWeb.address.toHex(value);
+        return hex.replace(/^41/, '0x');
+    }
+    return value;
+};
+exports.sunioApi = {
+    getTradeQuote: async (input, deps) => {
+        const maybeTradeQuote = await (0, getSunioTradeQuote_1.getSunioTradeQuote)(input, deps);
+        return maybeTradeQuote.map(quote => [quote]);
+    },
+    getTradeRate: async (input, deps) => {
+        const maybeTradeRate = await (0, getSunioTradeRate_1.getSunioTradeRate)(input, deps);
+        return maybeTradeRate.map(rate => [rate]);
+    },
+    getUnsignedTronTransaction: async (args) => {
+        const { tradeQuote, stepIndex, from, slippageTolerancePercentageDecimal, assertGetTronChainAdapter, } = args;
+        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 adapter = assertGetTronChainAdapter(caip_1.tronChainId);
+        const sunioMetadata = step.sunioTransactionMetadata;
+        if (!sunioMetadata) {
+            throw new Error('[Sun.io] Missing transaction metadata in quote');
+        }
+        const rpcUrl = adapter.httpProvider.getRpcUrl();
+        const tronWeb = new tronweb_1.TronWeb({
+            fullHost: rpcUrl,
+        });
+        const routeParams = (0, buildSwapRouteParameters_1.buildSwapRouteParameters)(sunioMetadata.route, step.sellAmountIncludingProtocolFeesCryptoBaseUnit, step.buyAmountAfterFeesCryptoBaseUnit, from, slippageTolerancePercentageDecimal);
+        const parameters = [
+            { type: 'address[]', value: routeParams.path },
+            { type: 'string[]', value: routeParams.poolVersion },
+            { type: 'uint256[]', value: routeParams.versionLen },
+            { type: 'uint24[]', value: routeParams.fees },
+            {
+                type: 'tuple(uint256,uint256,address,uint256)',
+                value: convertAddressesToEvmFormat([
+                    routeParams.swapData.amountIn,
+                    routeParams.swapData.amountOutMin,
+                    routeParams.swapData.recipient,
+                    routeParams.swapData.deadline,
+                ]),
+            },
+        ];
+        const functionSelector = 'swapExactInput(address[],string[],uint256[],uint24[],(uint256,uint256,address,uint256))';
+        const isSellingNativeTrx = step.sellAsset.assetId === caip_1.tronAssetId;
+        const callValue = isSellingNativeTrx
+            ? Number(step.sellAmountIncludingProtocolFeesCryptoBaseUnit)
+            : 0;
+        const options = {
+            feeLimit: 100_000_000,
+            callValue,
+        };
+        const txData = await tronWeb.transactionBuilder.triggerSmartContract(constants_1.SUNIO_SMART_ROUTER_CONTRACT, functionSelector, options, parameters, from);
+        if (!txData.result || !txData.result.result) {
+            throw new Error('[Sun.io] Failed to build swap transaction');
+        }
+        const transaction = txData.transaction;
+        const rawDataHex = typeof transaction.raw_data_hex === 'string'
+            ? transaction.raw_data_hex
+            : Buffer.isBuffer(transaction.raw_data_hex)
+                ? transaction.raw_data_hex.toString('hex')
+                : Array.isArray(transaction.raw_data_hex)
+                    ? Buffer.from(transaction.raw_data_hex).toString('hex')
+                    : (() => {
+                        throw new Error(`Unexpected raw_data_hex type: ${typeof transaction.raw_data_hex}`);
+                    })();
+        if (!/^[0-9a-fA-F]+$/.test(rawDataHex)) {
+            throw new Error(`Invalid raw_data_hex format: ${rawDataHex.slice(0, 100)}`);
+        }
+        const accountNumber = step.accountNumber;
+        if (accountNumber === undefined) {
+            throw new Error('[Sun.io] accountNumber is required for execution');
+        }
+        const bip44Params = adapter.getBip44Params({ accountNumber });
+        const addressNList = (0, chain_adapters_1.toAddressNList)(bip44Params);
+        return {
+            addressNList,
+            rawDataHex,
+            transaction,
+        };
+    },
+    getTronTransactionFees: getTronTransactionFees_1.getTronTransactionFees,
+    checkTradeStatus: async ({ txHash, assertGetTronChainAdapter }) => {
+        try {
+            // Wait for TronGrid indexing to avoid false "REVERT"
+            await sleep(2000);
+            const adapter = assertGetTronChainAdapter(caip_1.tronChainId);
+            const tx = await adapter.httpProvider.getTransaction({ txid: txHash });
+            if (!tx) {
+                return (0, utils_1.createDefaultStatusResponse)(txHash);
+            }
+            const contractRet = tx.ret?.[0]?.contractRet;
+            // Only mark as confirmed if SUCCESS AND has confirmations (in a block)
+            const status = contractRet === 'SUCCESS' && tx.confirmations > 0
+                ? unchained_client_1.TxStatus.Confirmed
+                : contractRet === 'REVERT'
+                    ? unchained_client_1.TxStatus.Failed
+                    : unchained_client_1.TxStatus.Pending;
+            return {
+                status,
+                buyTxHash: txHash,
+                message: undefined,
+            };
+        }
+        catch (error) {
+            console.error('[Sun.io] Error checking trade status:', error);
+            return (0, utils_1.createDefaultStatusResponse)(txHash);
+        }
+    },
+};

package/dist/cjs/swappers/SunioSwapper/getSunioTradeQuote/getSunioTradeQuote.d.ts

@@ -0,0 +1,3 @@
+import type { Result } from '@sniptt/monads';
+import type { CommonTradeQuoteInput, GetTronTradeQuoteInput, SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types';
+export declare const getSunioTradeQuote: (input: GetTronTradeQuoteInput | CommonTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote, SwapErrorRight>>;

package/dist/cjs/swappers/SunioSwapper/getSunioTradeQuote/getSunioTradeQuote.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSunioTradeQuote = void 0;
+const getQuoteOrRate_1 = require("../utils/getQuoteOrRate");
+const getSunioTradeQuote = (input, deps) => {
+    return (0, getQuoteOrRate_1.getQuoteOrRate)(input, deps);
+};
+exports.getSunioTradeQuote = getSunioTradeQuote;

package/dist/cjs/swappers/SunioSwapper/getSunioTradeRate/getSunioTradeRate.d.ts

@@ -0,0 +1,3 @@
+import type { Result } from '@sniptt/monads';
+import type { GetTradeRateInput, SwapErrorRight, SwapperDeps, TradeRate } from '../../../types';
+export declare const getSunioTradeRate: (input: GetTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate, SwapErrorRight>>;

package/dist/cjs/swappers/SunioSwapper/getSunioTradeRate/getSunioTradeRate.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSunioTradeRate = void 0;
+const getQuoteOrRate_1 = require("../utils/getQuoteOrRate");
+const getSunioTradeRate = (input, deps) => {
+    return (0, getQuoteOrRate_1.getQuoteOrRate)(input, deps);
+};
+exports.getSunioTradeRate = getSunioTradeRate;

package/dist/cjs/swappers/SunioSwapper/index.d.ts

@@ -0,0 +1,4 @@
+export { sunioApi } from './endpoints';
+export { sunioSwapper } from './SunioSwapper';
+export * from './types';
+export * from './utils/constants';