@shapeshiftoss/swapper 17.6.7 → 17.6.9

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

@@ -0,0 +1,47 @@
+import { Err, Ok } from '@sniptt/monads';
+import { makeSwapErrorRight } from '../../../utils.js';
+export const fetchAxelarscanBridgeStatus = async (sourceTxHash) => {
+    try {
+        const response = await fetch(`https://api.axelarscan.io/gmp/searchGMP?txHash=${sourceTxHash}`);
+        if (!response.ok) {
+            return Err(makeSwapErrorRight({
+                message: `Axelarscan API error: ${response.statusText}`,
+            }));
+        }
+        const data = await response.json();
+        if (!data.data || data.data.length === 0) {
+            return 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 Ok({
+                status: 'confirmed',
+                destinationTxHash,
+            });
+        }
+        if (bridgeData.status === 'error') {
+            return Ok({
+                status: 'failed',
+                errorMessage: bridgeData.error?.message || 'Bridge failed',
+            });
+        }
+        return Ok({
+            status: 'pending',
+        });
+    }
+    catch (error) {
+        return Err(makeSwapErrorRight({
+            message: 'Failed to fetch Axelarscan bridge status',
+            cause: error,
+        }));
+    }
+};
+export const getAxelarscanTrackingLink = (sourceTxHash) => `https://axelarscan.io/gmp/${sourceTxHash}`;

package/dist/esm/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/esm/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.js';
+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/esm/swappers/PortalsSwapper/utils/fetchSquidStatus.js

@@ -0,0 +1,52 @@
+import { fromChainId } from '@shapeshiftoss/caip';
+import { Err, Ok } from '@sniptt/monads';
+import { makeSwapErrorRight } from '../../../utils.js';
+export const fetchSquidBridgeStatus = async (sourceTxHash, sourceChainId, destinationChainId) => {
+    try {
+        const fromChain = fromChainId(sourceChainId).chainReference;
+        const toChain = 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 Err(makeSwapErrorRight({
+                message: `Squid API error: ${response.statusText}`,
+            }));
+        }
+        const data = await response.json();
+        const destinationTxHash = data.toChain?.transactionId;
+        if (data.squidTransactionStatus === 'success') {
+            return Ok({
+                status: 'confirmed',
+                destinationTxHash,
+            });
+        }
+        if (data.squidTransactionStatus === 'partial_success' ||
+            data.squidTransactionStatus === 'needs_gas') {
+            return Ok({
+                status: 'failed',
+            });
+        }
+        return Ok({
+            status: 'pending',
+        });
+    }
+    catch (error) {
+        return Err(makeSwapErrorRight({
+            message: 'Failed to fetch Squid bridge status',
+            cause: error,
+        }));
+    }
+};
+export const getSquidTrackingLink = (sourceTxHash, squidStatus, sellAssetExplorerTxLink, buyAssetExplorerTxLink) => {
+    if (squidStatus.status === 'confirmed' && squidStatus.destinationTxHash) {
+        return `${buyAssetExplorerTxLink}${squidStatus.destinationTxHash}`;
+    }
+    return `${sellAssetExplorerTxLink}${sourceTxHash}`;
+};

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

@@ -1,7 +1,7 @@
-import { arbitrumChainId, avalancheChainId, baseChainId, bscChainId, btcChainId, ethChainId, gnosisChainId, monadChainId, optimismChainId, polygonChainId, solanaChainId, tronChainId, } from '@shapeshiftoss/caip';
+import { arbitrumChainId, avalancheChainId, baseChainId, bscChainId, btcChainId, ethChainId, gnosisChainId, hyperEvmChainId, katanaChainId, monadChainId, optimismChainId, plasmaChainId, polygonChainId, solanaChainId, tronChainId, } from '@shapeshiftoss/caip';
 import invert from 'lodash/invert';
 import { zeroAddress } from 'viem';
-import { arbitrum, avalanche, base, bsc, gnosis, mainnet as ethereum, monad, optimism, polygon, } from 'viem/chains';
+import { arbitrum, avalanche, base, bsc, gnosis, hyperEvm, katana, mainnet as ethereum, monad, optimism, plasma, polygon, } from 'viem/chains';
 import { TradeQuoteError } from '../../types.js';
 import { RelayErrorCode } from './utils/types.js';
 export const chainIdToRelayChainId = {
@@ -19,6 +19,9 @@ export const chainIdToRelayChainId = {
     [bscChainId]: bsc.id,
     [tronChainId]: 728126428,
     [monadChainId]: monad.id,
+    [hyperEvmChainId]: hyperEvm.id,
+    [plasmaChainId]: plasma.id,
+    [katanaChainId]: katana.id,
 };
 export var RelayStatusMessage;
 (function (RelayStatusMessage) {

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

@@ -1,4 +1,4 @@
 import { relayService } from './relayService.js';
 export const fetchRelayTrade = async (params, config) => {
-    return await relayService.post(`${config.VITE_RELAY_API_URL}/quote`, params);
+    return await relayService.post(`${config.VITE_RELAY_API_URL}/quote/v2`, params);
 };

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

@@ -1,4 +1,4 @@
-import { btcChainId, fromChainId, solanaChainId, tronChainId } from '@shapeshiftoss/caip';
+import { btcChainId, fromChainId, monadChainId, solanaChainId, tronChainId, } from '@shapeshiftoss/caip';
 import { evm, isEvmChainId } from '@shapeshiftoss/chain-adapters';
 import { bnOrZero, convertBasisPointsToPercentage, convertDecimalPercentageToBasisPoints, convertPrecision, DAO_TREASURY_BASE, } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
@@ -13,7 +13,7 @@ import { MAXIMUM_SUPPORTED_RELAY_STEPS, relayErrorCodeToTradeQuoteError } from '
 import { getRelayAssetAddress } from '../utils/getRelayAssetAddress.js';
 import { relayTokenToAsset } from '../utils/relayTokenToAsset.js';
 import { relayTokenToAssetId } from '../utils/relayTokenToAssetId.js';
-import { isRelayError, isRelayQuoteEvmItemData, isRelayQuoteSolanaItemData, isRelayQuoteUtxoItemData, } from '../utils/types.js';
+import { isRelayError, isRelayQuoteEvmItemData, isRelayQuoteSolanaItemData, isRelayQuoteTronItemData, isRelayQuoteUtxoItemData, } from '../utils/types.js';
 import { fetchRelayTrade } from './fetchRelayTrade.js';
 import { getRelayDefaultUserAddress } from './getRelayDefaultUserAddress.js';
 import { getRelayPsbtRelayer } from './getRelayPsbtRelayer.js';
@@ -353,6 +353,10 @@ export 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 === monadChainId
+                            ? Number(selectedItem.data.gas)
+                            : undefined,
                     }, {
                         apiKey: deps.config.VITE_TENDERLY_API_KEY,
                         accountSlug: deps.config.VITE_TENDERLY_ACCOUNT_SLUG,
@@ -414,7 +418,8 @@ export 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,
@@ -436,6 +441,16 @@ export async function getTrade({ input, deps, relayChainMap, }) {
                     },
                 };
             }
+            if (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/esm/swappers/RelaySwapper/utils/relayTokenToAssetId.js

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

package/dist/esm/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/esm/swappers/RelaySwapper/utils/types.js

@@ -7,6 +7,9 @@ export const isRelayQuoteEvmItemData = (item) => {
 export const isRelayQuoteSolanaItemData = (item) => {
     return 'instructions' in item;
 };
+export const isRelayQuoteTronItemData = (item) => {
+    return 'type' in item && 'parameter' in item;
+};
 export var RelayErrorCode;
 (function (RelayErrorCode) {
     RelayErrorCode["AmountTooLow"] = "AMOUNT_TOO_LOW";

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

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

package/dist/esm/swappers/SunioSwapper/SunioSwapper.js

@@ -0,0 +1,4 @@
+import { executeTronTransaction } from '../../utils.js';
+export const sunioSwapper = {
+    executeTronTransaction,
+};

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

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

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

@@ -0,0 +1,128 @@
+import { tronAssetId, tronChainId } from '@shapeshiftoss/caip';
+import { toAddressNList } from '@shapeshiftoss/chain-adapters';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import { TronWeb } from 'tronweb';
+import { getTronTransactionFees } from '../../tron-utils/getTronTransactionFees.js';
+import { createDefaultStatusResponse, getExecutableTradeStep, isExecutableTradeQuote, } from '../../utils.js';
+import { getSunioTradeQuote } from './getSunioTradeQuote/getSunioTradeQuote.js';
+import { getSunioTradeRate } from './getSunioTradeRate/getSunioTradeRate.js';
+import { buildSwapRouteParameters } from './utils/buildSwapRouteParameters.js';
+import { SUNIO_SMART_ROUTER_CONTRACT } from './utils/constants.js';
+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.isAddress(value)) {
+        const hex = TronWeb.address.toHex(value);
+        return hex.replace(/^41/, '0x');
+    }
+    return value;
+};
+export const sunioApi = {
+    getTradeQuote: async (input, deps) => {
+        const maybeTradeQuote = await getSunioTradeQuote(input, deps);
+        return maybeTradeQuote.map(quote => [quote]);
+    },
+    getTradeRate: async (input, deps) => {
+        const maybeTradeRate = await getSunioTradeRate(input, deps);
+        return maybeTradeRate.map(rate => [rate]);
+    },
+    getUnsignedTronTransaction: async (args) => {
+        const { tradeQuote, stepIndex, from, slippageTolerancePercentageDecimal, assertGetTronChainAdapter, } = args;
+        if (!isExecutableTradeQuote(tradeQuote)) {
+            throw new Error('Unable to execute a trade rate quote');
+        }
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const adapter = assertGetTronChainAdapter(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({
+            fullHost: rpcUrl,
+        });
+        const routeParams = 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 === tronAssetId;
+        const callValue = isSellingNativeTrx
+            ? Number(step.sellAmountIncludingProtocolFeesCryptoBaseUnit)
+            : 0;
+        const options = {
+            feeLimit: 100_000_000,
+            callValue,
+        };
+        const txData = await tronWeb.transactionBuilder.triggerSmartContract(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 = toAddressNList(bip44Params);
+        return {
+            addressNList,
+            rawDataHex,
+            transaction,
+        };
+    },
+    getTronTransactionFees,
+    checkTradeStatus: async ({ txHash, assertGetTronChainAdapter }) => {
+        try {
+            // Wait for TronGrid indexing to avoid false "REVERT"
+            await sleep(2000);
+            const adapter = assertGetTronChainAdapter(tronChainId);
+            const tx = await adapter.httpProvider.getTransaction({ txid: txHash });
+            if (!tx) {
+                return 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
+                ? TxStatus.Confirmed
+                : contractRet === 'REVERT'
+                    ? TxStatus.Failed
+                    : TxStatus.Pending;
+            return {
+                status,
+                buyTxHash: txHash,
+                message: undefined,
+            };
+        }
+        catch (error) {
+            console.error('[Sun.io] Error checking trade status:', error);
+            return createDefaultStatusResponse(txHash);
+        }
+    },
+};

package/dist/esm/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.js';
+export declare const getSunioTradeQuote: (input: GetTronTradeQuoteInput | CommonTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote, SwapErrorRight>>;

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

@@ -0,0 +1,4 @@
+import { getQuoteOrRate } from '../utils/getQuoteOrRate.js';
+export const getSunioTradeQuote = (input, deps) => {
+    return getQuoteOrRate(input, deps);
+};

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

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

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

@@ -0,0 +1,4 @@
+import { getQuoteOrRate } from '../utils/getQuoteOrRate.js';
+export const getSunioTradeRate = (input, deps) => {
+    return getQuoteOrRate(input, deps);
+};

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

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

package/dist/esm/swappers/SunioSwapper/index.js

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

package/dist/esm/swappers/SunioSwapper/types.d.ts

@@ -0,0 +1,22 @@
+import type { tronChainId } from '@shapeshiftoss/caip';
+export type SunioSupportedChainId = typeof tronChainId;
+export type SunioRoute = {
+    amountIn: string;
+    amountOut: string;
+    inUsd: string;
+    outUsd: string;
+    impact: string;
+    fee: string;
+    tokens: string[];
+    symbols: string[];
+    poolFees: string[];
+    poolVersions: string[];
+    stepAmountsOut: string[];
+};
+export type SunioQuoteResponse = {
+    code: number;
+    message: string;
+    data: SunioRoute[];
+};
+export declare const SUNIO_SUPPORTED_DEX_TYPES: readonly ["SUNSWAP_V1", "SUNSWAP_V2", "SUNSWAP_V3", "PSM", "CURVE", "CURVE_COMBINATION", "WTRX"];
+export type SunioDexType = (typeof SUNIO_SUPPORTED_DEX_TYPES)[number];

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

@@ -0,0 +1,9 @@
+export const SUNIO_SUPPORTED_DEX_TYPES = [
+    'SUNSWAP_V1',
+    'SUNSWAP_V2',
+    'SUNSWAP_V3',
+    'PSM',
+    'CURVE',
+    'CURVE_COMBINATION',
+    'WTRX',
+];

package/dist/esm/swappers/SunioSwapper/utils/abi.d.ts

@@ -0,0 +1,48 @@
+export declare const SUNSWAP_ROUTER_ABI: readonly [{
+    readonly name: "swapExactInput";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "path";
+        readonly type: "address[]";
+    }, {
+        readonly internalType: "string[]";
+        readonly name: "poolVersion";
+        readonly type: "string[]";
+    }, {
+        readonly internalType: "uint256[]";
+        readonly name: "versionLen";
+        readonly type: "uint256[]";
+    }, {
+        readonly internalType: "uint24[]";
+        readonly name: "fees";
+        readonly type: "uint24[]";
+    }, {
+        readonly internalType: "struct SwapData";
+        readonly name: "data";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "amountIn";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "amountOutMin";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "address";
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    }];
+    readonly outputs: readonly [{
+        readonly internalType: "uint256[]";
+        readonly name: "amountsOut";
+        readonly type: "uint256[]";
+    }];
+}];

package/dist/esm/swappers/SunioSwapper/utils/abi.js

@@ -0,0 +1,25 @@
+export const SUNSWAP_ROUTER_ABI = [
+    {
+        name: 'swapExactInput',
+        type: 'function',
+        stateMutability: 'payable',
+        inputs: [
+            { internalType: 'address[]', name: 'path', type: 'address[]' },
+            { internalType: 'string[]', name: 'poolVersion', type: 'string[]' },
+            { internalType: 'uint256[]', name: 'versionLen', type: 'uint256[]' },
+            { internalType: 'uint24[]', name: 'fees', type: 'uint24[]' },
+            {
+                internalType: 'struct SwapData',
+                name: 'data',
+                type: 'tuple',
+                components: [
+                    { internalType: 'uint256', name: 'amountIn', type: 'uint256' },
+                    { internalType: 'uint256', name: 'amountOutMin', type: 'uint256' },
+                    { internalType: 'address', name: 'to', type: 'address' },
+                    { internalType: 'uint256', name: 'deadline', type: 'uint256' },
+                ],
+            },
+        ],
+        outputs: [{ internalType: 'uint256[]', name: 'amountsOut', type: 'uint256[]' }],
+    },
+];

package/dist/esm/swappers/SunioSwapper/utils/buildSwapRouteParameters.d.ts

@@ -0,0 +1,14 @@
+import type { SunioRoute } from '../types.js';
+export type SwapRouteParameters = {
+    path: string[];
+    poolVersion: string[];
+    versionLen: number[];
+    fees: number[];
+    swapData: {
+        amountIn: string;
+        amountOutMin: string;
+        recipient: string;
+        deadline: number;
+    };
+};
+export declare const buildSwapRouteParameters: (route: SunioRoute, sellAmountCryptoBaseUnit: string, minBuyAmountCryptoBaseUnit: string, recipient: string, slippageTolerancePercentageDecimal: string) => SwapRouteParameters;

package/dist/esm/swappers/SunioSwapper/utils/buildSwapRouteParameters.js

@@ -0,0 +1,28 @@
+import { bn } from '@shapeshiftoss/utils';
+export const buildSwapRouteParameters = (route, sellAmountCryptoBaseUnit, minBuyAmountCryptoBaseUnit, recipient, slippageTolerancePercentageDecimal) => {
+    const path = route.tokens;
+    const poolVersion = route.poolVersions;
+    const versionLen = poolVersion.map((_, index) => {
+        if (index === poolVersion.length - 1) {
+            return path.length - index;
+        }
+        return 2;
+    });
+    const fees = route.poolFees.map(fee => Number(fee));
+    const amountOutWithSlippage = bn(minBuyAmountCryptoBaseUnit)
+        .times(bn(1).minus(slippageTolerancePercentageDecimal))
+        .toFixed(0);
+    const swapData = {
+        amountIn: sellAmountCryptoBaseUnit,
+        amountOutMin: amountOutWithSlippage,
+        recipient,
+        deadline: Math.floor(Date.now() / 1000) + 60 * 20,
+    };
+    return {
+        path,
+        poolVersion,
+        versionLen,
+        fees,
+        swapData,
+    };
+};

package/dist/esm/swappers/SunioSwapper/utils/buildSwapTransaction.d.ts

@@ -0,0 +1,11 @@
+import type { SunioRoute } from '../types.js';
+export type BuildSwapTransactionArgs = {
+    route: SunioRoute;
+    from: string;
+    to: string;
+    sellAmountCryptoBaseUnit: string;
+    minBuyAmountCryptoBaseUnit: string;
+    rpcUrl: string;
+    deadline?: number;
+};
+export declare const buildSunioSwapTransaction: (args: BuildSwapTransactionArgs) => Promise<any>;