@shapeshiftoss/swapper 17.6.6 → 17.6.8

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

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

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRelayError = exports.RelayErrorCode = exports.isRelayQuoteTronItemData = exports.isRelayQuoteSolanaItemData = exports.isRelayQuoteEvmItemData = exports.isRelayQuoteUtxoItemData = void 0;
+const isRelayQuoteUtxoItemData = (item) => {
+    return 'psbt' in item;
+};
+exports.isRelayQuoteUtxoItemData = isRelayQuoteUtxoItemData;
+const isRelayQuoteEvmItemData = (item) => {
+    return 'to' in item && 'data' in item && 'value' in item;
+};
+exports.isRelayQuoteEvmItemData = isRelayQuoteEvmItemData;
+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";
+    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 || (exports.RelayErrorCode = RelayErrorCode = {}));
+const isRelayError = (error) => {
+    return typeof error === 'object' && error !== null && 'errorCode' in error && 'message' in error;
+};
+exports.isRelayError = isRelayError;

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';

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

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sunioSwapper = exports.sunioApi = void 0;
+var endpoints_1 = require("./endpoints");
+Object.defineProperty(exports, "sunioApi", { enumerable: true, get: function () { return endpoints_1.sunioApi; } });
+var SunioSwapper_1 = require("./SunioSwapper");
+Object.defineProperty(exports, "sunioSwapper", { enumerable: true, get: function () { return SunioSwapper_1.sunioSwapper; } });
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils/constants"), exports);

package/dist/cjs/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/cjs/swappers/SunioSwapper/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUNIO_SUPPORTED_DEX_TYPES = void 0;
+exports.SUNIO_SUPPORTED_DEX_TYPES = [
+    'SUNSWAP_V1',
+    'SUNSWAP_V2',
+    'SUNSWAP_V3',
+    'PSM',
+    'CURVE',
+    'CURVE_COMBINATION',
+    'WTRX',
+];

package/dist/cjs/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/cjs/swappers/SunioSwapper/utils/abi.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUNSWAP_ROUTER_ABI = void 0;
+exports.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[]' }],
+    },
+];