@shapeshiftoss/swapper 17.6.6 → 17.6.8

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

@@ -0,0 +1,126 @@
+import { ASSET_NAMESPACE, ASSET_REFERENCE, btcChainId, CHAIN_REFERENCE, fromChainId, solanaChainId, toAssetId, tronChainId, } from '@shapeshiftoss/caip';
+import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { DEFAULT_RELAY_EVM_TOKEN_ADDRESS, RELAY_BTC_TOKEN_ADDRESS, RELAY_SOLANA_TOKEN_ADDRESS, RELAY_TRON_TOKEN_ADDRESS, relayChainIdToChainId, } from '../constant.js';
+export const relayTokenToAssetId = (relayToken) => {
+    const chainId = relayChainIdToChainId[relayToken.chainId];
+    const { chainReference } = fromChainId(chainId);
+    const isNativeAsset = (() => {
+        if (isEvmChainId(chainId)) {
+            return relayToken.address === DEFAULT_RELAY_EVM_TOKEN_ADDRESS;
+        }
+        if (chainId === btcChainId) {
+            return relayToken.address === RELAY_BTC_TOKEN_ADDRESS;
+        }
+        if (chainId === solanaChainId) {
+            return relayToken.address === RELAY_SOLANA_TOKEN_ADDRESS;
+        }
+        if (chainId === tronChainId) {
+            return relayToken.address === RELAY_TRON_TOKEN_ADDRESS;
+        }
+        return false;
+    })();
+    const { assetReference, assetNamespace } = (() => {
+        if (!isNativeAsset) {
+            const assetNamespace = (() => {
+                switch (true) {
+                    case isEvmChainId(chainId):
+                        return ASSET_NAMESPACE.erc20;
+                    case CHAIN_REFERENCE.SolanaMainnet === chainReference:
+                        return ASSET_NAMESPACE.splToken;
+                    case CHAIN_REFERENCE.TronMainnet === chainReference:
+                        return ASSET_NAMESPACE.trc20;
+                    default:
+                        throw Error(`chainReference '${chainReference}' not supported`);
+                }
+            })();
+            return {
+                assetReference: relayToken.address,
+                assetNamespace,
+            };
+        }
+        switch (chainReference) {
+            case CHAIN_REFERENCE.EthereumMainnet:
+                return {
+                    assetReference: ASSET_REFERENCE.Ethereum,
+                    assetNamespace: ASSET_NAMESPACE.slip44,
+                };
+            case CHAIN_REFERENCE.AvalancheCChain:
+                return {
+                    assetReference: ASSET_REFERENCE.AvalancheC,
+                    assetNamespace: ASSET_NAMESPACE.slip44,
+                };
+            case CHAIN_REFERENCE.OptimismMainnet:
+                return {
+                    assetReference: ASSET_REFERENCE.Optimism,
+                    assetNamespace: ASSET_NAMESPACE.slip44,
+                };
+            case CHAIN_REFERENCE.PolygonMainnet:
+                return {
+                    assetReference: ASSET_REFERENCE.Polygon,
+                    assetNamespace: ASSET_NAMESPACE.slip44,
+                };
+            case CHAIN_REFERENCE.GnosisMainnet:
+                return {
+                    assetReference: ASSET_REFERENCE.Gnosis,
+                    assetNamespace: ASSET_NAMESPACE.slip44,
+                };
+            case CHAIN_REFERENCE.ArbitrumMainnet:
+                return {
+                    assetReference: ASSET_REFERENCE.Arbitrum,
+                    assetNamespace: ASSET_NAMESPACE.slip44,
+                };
+            case CHAIN_REFERENCE.BaseMainnet:
+                return {
+                    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,
+                    assetNamespace: ASSET_NAMESPACE.slip44,
+                };
+            case CHAIN_REFERENCE.SolanaMainnet:
+                return {
+                    assetReference: ASSET_REFERENCE.Solana,
+                    assetNamespace: ASSET_NAMESPACE.slip44,
+                };
+            case CHAIN_REFERENCE.TronMainnet:
+                return {
+                    assetReference: ASSET_REFERENCE.Tron,
+                    assetNamespace: ASSET_NAMESPACE.slip44,
+                };
+            case CHAIN_REFERENCE.MonadMainnet:
+                return {
+                    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`);
+        }
+    })();
+    return toAssetId({
+        chainId,
+        assetNamespace,
+        assetReference,
+    });
+};

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

@@ -0,0 +1,167 @@
+import type { Asset } from '@shapeshiftoss/types';
+export type RelayTradeBaseParams = {
+    buyAsset: Asset;
+    sellAsset: Asset;
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
+    affiliateBps: string;
+};
+export type RelayTradeInputParams<T extends 'rate' | 'quote'> = RelayTradeBaseParams & {
+    quoteOrRate: T;
+    receiveAddress: T extends 'rate' ? string | undefined : string;
+    sendAddress: T extends 'rate' ? undefined : string;
+    accountNumber: T extends 'rate' ? undefined : number;
+    slippageTolerancePercentageDecimal?: string;
+    xpub: string | undefined;
+};
+export type RelayTransactionMetadata = {
+    to?: string;
+    from?: string;
+    value?: string;
+    data?: string;
+    gasLimit?: string;
+    psbt?: string;
+    opReturnData?: string;
+    relayId: string;
+};
+export type RelayStatus = {
+    status: 'success' | 'failed' | 'pending' | 'refund' | 'delayed' | 'waiting';
+    details?: string;
+    inTxHashes: string[];
+    txHashes: string[];
+    time: number;
+    originChainId: number;
+    destinationChainId: number;
+};
+export type AppFee = {
+    recipient: string;
+    fee: string;
+};
+export type Transaction = {
+    from: string;
+    to: string;
+    value: string;
+    data: string;
+};
+export type RelayFetchQuoteParams<T extends 'quote' | 'rate'> = {
+    user: T extends 'quote' ? string : undefined;
+    originChainId: number;
+    destinationChainId: number;
+    originCurrency: string;
+    destinationCurrency: string;
+    tradeType: 'EXACT_INPUT' | 'EXACT_OUTPUT' | 'EXPECTED_OUTPUT';
+    recipient?: string;
+    amount?: string;
+    referrer?: string;
+    refundOnOrigin?: boolean;
+    refundTo: string;
+    slippageTolerance?: string;
+    appFees?: AppFee[];
+};
+export type RelayToken = {
+    chainId: number;
+    address: string;
+    symbol: string;
+    name: string;
+    decimals: number;
+};
+export type RelayCurrencyData = {
+    currency: RelayToken;
+    amount: string;
+    amountFormatted: string;
+    amountUsd: string;
+    minimumAmount: string;
+};
+export type RelayFees = {
+    gas: RelayCurrencyData;
+    relayer: RelayCurrencyData;
+    app: RelayCurrencyData;
+};
+export type QuoteDetails = {
+    currencyOut: RelayCurrencyData;
+    rate: string;
+    slippageTolerance: {
+        origin: {
+            percent: string;
+        };
+        destination: {
+            percent: string;
+        };
+    };
+    timeEstimate: number;
+};
+export type RelayQuoteEvmItemData = {
+    to?: string;
+    data?: string;
+    value?: string;
+    gas?: string;
+};
+export type RelayQuoteUtxoItemData = {
+    psbt?: string;
+    to?: string;
+    opReturnData?: string;
+};
+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 | RelayQuoteTronItemData;
+};
+export type RelayQuoteStep = {
+    id: string;
+    requestId: string;
+    items?: RelayQuoteItem[];
+};
+export type RelayQuote = {
+    fees: RelayFees;
+    details: QuoteDetails;
+    steps: RelayQuoteStep[];
+};
+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;
+        isSigner: boolean;
+        isWritable: boolean;
+    }[];
+    data: string;
+    programId: string;
+};
+export declare enum RelayErrorCode {
+    AmountTooLow = "AMOUNT_TOO_LOW",
+    ChainDisabled = "CHAIN_DISABLED",
+    Erc20RouterAddressNotFound = "ERC20_ROUTER_ADDRESS_NOT_FOUND",
+    ExtraTransactionsNotSupported = "EXTRA_TXS_NOT_SUPPORTED",
+    InsufficientFunds = "INSUFFICIENT_FUNDS",
+    InsufficientLiquidity = "INSUFFICIENT_LIQUIDITY",
+    InvalidAddress = "INVALID_ADDRESS",
+    InvalidExtraTransactions = "INVALID_EXTRA_TXS",
+    NoQuotes = "NO_QUOTES",
+    NoSwapRoutesFound = "NO_SWAP_ROUTES_FOUND",
+    PermitFailed = "PERMIT_FAILED",
+    SwapImpactTooHigh = "SWAP_IMPACT_TOO_HIGH",
+    SwapQuoteFailed = "SWAP_QUOTE_FAILED",
+    Unauthorized = "UNAUTHORIZED",
+    UnknownError = "UNKNOWN_ERROR",
+    UnsupportedChain = "UNSUPPORTED_CHAIN",
+    UnsupportedCurrency = "UNSUPPORTED_CURRENCY",
+    UnsupportedExecutionType = "UNSUPPORTED_EXECUTION_TYPE",
+    UnsupportedRoute = "UNSUPPORTED_ROUTE",
+    UserRecipientMismatch = "USER_RECIPIENT_MISMATCH"
+}
+export type RelayError = {
+    errorCode: RelayErrorCode;
+    message: string;
+};
+export declare const isRelayError: (error: unknown) => error is RelayError;

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

@@ -0,0 +1,38 @@
+export const isRelayQuoteUtxoItemData = (item) => {
+    return 'psbt' in item;
+};
+export const isRelayQuoteEvmItemData = (item) => {
+    return 'to' in item && 'data' in item && 'value' in 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";
+    RelayErrorCode["ChainDisabled"] = "CHAIN_DISABLED";
+    RelayErrorCode["Erc20RouterAddressNotFound"] = "ERC20_ROUTER_ADDRESS_NOT_FOUND";
+    RelayErrorCode["ExtraTransactionsNotSupported"] = "EXTRA_TXS_NOT_SUPPORTED";
+    RelayErrorCode["InsufficientFunds"] = "INSUFFICIENT_FUNDS";
+    RelayErrorCode["InsufficientLiquidity"] = "INSUFFICIENT_LIQUIDITY";
+    RelayErrorCode["InvalidAddress"] = "INVALID_ADDRESS";
+    RelayErrorCode["InvalidExtraTransactions"] = "INVALID_EXTRA_TXS";
+    RelayErrorCode["NoQuotes"] = "NO_QUOTES";
+    RelayErrorCode["NoSwapRoutesFound"] = "NO_SWAP_ROUTES_FOUND";
+    RelayErrorCode["PermitFailed"] = "PERMIT_FAILED";
+    RelayErrorCode["SwapImpactTooHigh"] = "SWAP_IMPACT_TOO_HIGH";
+    RelayErrorCode["SwapQuoteFailed"] = "SWAP_QUOTE_FAILED";
+    RelayErrorCode["Unauthorized"] = "UNAUTHORIZED";
+    RelayErrorCode["UnknownError"] = "UNKNOWN_ERROR";
+    RelayErrorCode["UnsupportedChain"] = "UNSUPPORTED_CHAIN";
+    RelayErrorCode["UnsupportedCurrency"] = "UNSUPPORTED_CURRENCY";
+    RelayErrorCode["UnsupportedExecutionType"] = "UNSUPPORTED_EXECUTION_TYPE";
+    RelayErrorCode["UnsupportedRoute"] = "UNSUPPORTED_ROUTE";
+    RelayErrorCode["UserRecipientMismatch"] = "USER_RECIPIENT_MISMATCH";
+})(RelayErrorCode || (RelayErrorCode = {}));
+export const isRelayError = (error) => {
+    return typeof error === 'object' && error !== null && 'errorCode' in error && 'message' in error;
+};

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,
+    };
+};