@shapeshiftoss/swapper 17.6.6 → 17.6.8

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

@@ -0,0 +1,14 @@
+import type { SunioRoute } from '../types';
+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/cjs/swappers/SunioSwapper/utils/buildSwapRouteParameters.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSwapRouteParameters = void 0;
+const utils_1 = require("@shapeshiftoss/utils");
+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 = (0, utils_1.bn)(minBuyAmountCryptoBaseUnit)
+        .times((0, utils_1.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,
+    };
+};
+exports.buildSwapRouteParameters = buildSwapRouteParameters;

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

@@ -0,0 +1,11 @@
+import type { SunioRoute } from '../types';
+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>;

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSunioSwapTransaction = void 0;
+const tronweb_1 = require("tronweb");
+const constants_1 = require("./constants");
+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;
+};
+const buildSunioSwapTransaction = async (args) => {
+    const { route, from, to, sellAmountCryptoBaseUnit, minBuyAmountCryptoBaseUnit, rpcUrl, deadline, } = args;
+    const tronWeb = new tronweb_1.TronWeb({
+        fullHost: rpcUrl,
+    });
+    const path = route.tokens;
+    const poolVersion = route.poolVersions;
+    const versionLen = Array(poolVersion.length).fill(2);
+    const fees = route.poolFees.map(fee => Number(fee));
+    const swapData = {
+        amountIn: sellAmountCryptoBaseUnit,
+        amountOutMin: minBuyAmountCryptoBaseUnit,
+        recipient: to,
+        deadline: deadline ?? Math.floor(Date.now() / 1000) + 60 * 20,
+    };
+    const parameters = [
+        { type: 'address[]', value: path },
+        { type: 'string[]', value: poolVersion },
+        { type: 'uint256[]', value: versionLen },
+        { type: 'uint24[]', value: fees },
+        {
+            type: 'tuple(uint256,uint256,address,uint256)',
+            value: convertAddressesToEvmFormat([
+                swapData.amountIn,
+                swapData.amountOutMin,
+                swapData.recipient,
+                swapData.deadline,
+            ]),
+        },
+    ];
+    const functionSelector = 'swapExactInput(address[],string[],uint256[],uint24[],(uint256,uint256,address,uint256))';
+    const options = {
+        feeLimit: 100_000_000,
+        callValue: 0,
+    };
+    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');
+    }
+    return txData.transaction;
+};
+exports.buildSunioSwapTransaction = buildSunioSwapTransaction;

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

@@ -0,0 +1,6 @@
+export declare const SUNIO_SUPPORTED_CHAIN_IDS: readonly [import("@shapeshiftoss/caip").ChainId];
+export declare const SUNIO_API_BASE_URL = "https://rot.endjgfsv.link";
+export declare const SUNIO_SMART_ROUTER_CONTRACT: "TCFNp179Lg46D16zKoumd4Poa2WFFdtqYj";
+export declare const DEFAULT_SLIPPAGE_PERCENTAGE = "0.005";
+export declare const SUNIO_DEX_TYPES: "PSM,CURVE,CURVE_COMBINATION,WTRX,SUNSWAP_V1,SUNSWAP_V2,SUNSWAP_V3";
+export declare const SUNIO_TRON_NATIVE_ADDRESS: "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb";

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUNIO_TRON_NATIVE_ADDRESS = exports.SUNIO_DEX_TYPES = exports.DEFAULT_SLIPPAGE_PERCENTAGE = exports.SUNIO_SMART_ROUTER_CONTRACT = exports.SUNIO_API_BASE_URL = exports.SUNIO_SUPPORTED_CHAIN_IDS = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+exports.SUNIO_SUPPORTED_CHAIN_IDS = [caip_1.tronChainId];
+// NOTE: This domain looks suspicious, but it's the official Sun.io backend API
+// Verified by inspecting XHR requests from sun.io's own frontend application
+// The sun.io frontend makes requests to this endpoint with origin: https://sun.io
+exports.SUNIO_API_BASE_URL = 'https://rot.endjgfsv.link';
+// Smart Exchange Router - aggregates liquidity across V1, V2, V3, PSM, and SunCurve
+// This is the current mainnet router that sun.io's frontend uses
+exports.SUNIO_SMART_ROUTER_CONTRACT = 'TCFNp179Lg46D16zKoumd4Poa2WFFdtqYj';
+exports.DEFAULT_SLIPPAGE_PERCENTAGE = '0.005';
+exports.SUNIO_DEX_TYPES = 'PSM,CURVE,CURVE_COMBINATION,WTRX,SUNSWAP_V1,SUNSWAP_V2,SUNSWAP_V3';
+// Native TRX token address (used when assetId is not a TRC-20 token)
+exports.SUNIO_TRON_NATIVE_ADDRESS = 'T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb';

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

@@ -0,0 +1,11 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types';
+import type { SunioQuoteResponse } from '../types';
+import type { SunioService } from './sunioService';
+export type FetchSunioQuoteParams = {
+    sellAssetId: AssetId;
+    buyAssetId: AssetId;
+    sellAmountCryptoBaseUnit: string;
+};
+export declare const fetchSunioQuote: (params: FetchSunioQuoteParams, service: SunioService) => Promise<Result<SunioQuoteResponse, SwapErrorRight>>;

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSunioQuote = void 0;
+const monads_1 = require("@sniptt/monads");
+const types_1 = require("../../../types");
+const utils_1 = require("../../../utils");
+const constants_1 = require("./constants");
+const helpers_1 = require("./helpers/helpers");
+const fetchSunioQuote = async (params, service) => {
+    try {
+        const { sellAssetId, buyAssetId, sellAmountCryptoBaseUnit } = params;
+        const fromToken = (0, helpers_1.assetIdToTronToken)(sellAssetId);
+        const toToken = (0, helpers_1.assetIdToTronToken)(buyAssetId);
+        const queryParams = {
+            fromToken,
+            toToken,
+            amountIn: sellAmountCryptoBaseUnit,
+            typeList: constants_1.SUNIO_DEX_TYPES,
+        };
+        const url = `${constants_1.SUNIO_API_BASE_URL}/swap/router`;
+        const maybeResponse = await service.get(url, {
+            params: queryParams,
+        });
+        if (maybeResponse.isErr()) {
+            return (0, monads_1.Err)(maybeResponse.unwrapErr());
+        }
+        const { data: response } = maybeResponse.unwrap();
+        if (response.code !== 0 || !response.data || response.data.length === 0) {
+            return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+                message: `[Sun.io] ${response.message || 'No routes found'}`,
+                code: types_1.TradeQuoteError.NoRouteFound,
+                details: { response },
+            }));
+        }
+        return (0, monads_1.Ok)(response);
+    }
+    catch (error) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: '[Sun.io] Failed to fetch quote',
+            code: types_1.TradeQuoteError.QueryFailed,
+            cause: error,
+        }));
+    }
+};
+exports.fetchSunioQuote = fetchSunioQuote;

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

@@ -0,0 +1,4 @@
+import type { Result } from '@sniptt/monads';
+import type { CommonTradeQuoteInput, GetTradeRateInput, GetTronTradeQuoteInput, SwapErrorRight, SwapperDeps, TradeQuote, TradeRate } from '../../../types';
+export declare function getQuoteOrRate(input: GetTronTradeQuoteInput | CommonTradeQuoteInput, deps: SwapperDeps): Promise<Result<TradeQuote, SwapErrorRight>>;
+export declare function getQuoteOrRate(input: GetTradeRateInput, deps: SwapperDeps): Promise<Result<TradeRate, SwapErrorRight>>;

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

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQuoteOrRate = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const tronweb_1 = require("tronweb");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const constants_1 = require("./constants");
+const fetchFromSunio_1 = require("./fetchFromSunio");
+const helpers_1 = require("./helpers/helpers");
+const sunioService_1 = require("./sunioService");
+async function getQuoteOrRate(input, deps) {
+    try {
+        const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, accountNumber, affiliateBps, slippageTolerancePercentageDecimal, } = input;
+        const { assertGetTronChainAdapter: _assertGetTronChainAdapter } = deps;
+        if (!(0, helpers_1.isSupportedChainId)(sellAsset.chainId)) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: `[${types_1.SwapperName.Sunio}] Unsupported chainId: ${sellAsset.chainId}`,
+                code: types_1.TradeQuoteError.UnsupportedChain,
+                details: { chainId: sellAsset.chainId },
+            }));
+        }
+        if (sellAsset.chainId !== buyAsset.chainId) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: `[${types_1.SwapperName.Sunio}] Cross-chain not supported`,
+                code: types_1.TradeQuoteError.CrossChainNotSupported,
+            }));
+        }
+        if (sellAsset.chainId !== caip_1.tronChainId) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: `[${types_1.SwapperName.Sunio}] Only TRON chain supported`,
+                code: types_1.TradeQuoteError.UnsupportedChain,
+            }));
+        }
+        const service = (0, sunioService_1.sunioServiceFactory)();
+        const maybeQuoteResponse = await (0, fetchFromSunio_1.fetchSunioQuote)({
+            sellAssetId: sellAsset.assetId,
+            buyAssetId: buyAsset.assetId,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        }, service);
+        if (maybeQuoteResponse.isErr()) {
+            return (0, monads_1.Err)(maybeQuoteResponse.unwrapErr());
+        }
+        const quoteResponse = maybeQuoteResponse.unwrap();
+        const bestRoute = quoteResponse.data[0];
+        if (!bestRoute) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: '[Sun.io] No routes available',
+                code: types_1.TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const isQuote = input.quoteOrRate === 'quote';
+        // For quotes, receiveAddress is required
+        if (isQuote && !receiveAddress) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: '[Sun.io] receiveAddress is required for quotes',
+                code: types_1.TradeQuoteError.InternalError,
+            }));
+        }
+        // Fetch network fees for both quotes and rates (when wallet connected)
+        let networkFeeCryptoBaseUnit = undefined;
+        // Estimate fees when we have an address to estimate from
+        if (receiveAddress) {
+            try {
+                const contractAddress = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
+                const isSellingNativeTrx = !contractAddress;
+                const tronWeb = new tronweb_1.TronWeb({ fullHost: deps.config.VITE_TRON_NODE_URL });
+                // Get chain parameters for pricing
+                const params = await tronWeb.trx.getChainParameters();
+                const bandwidthPrice = params.find(p => p.key === 'getTransactionFee')?.value ?? 1000;
+                const energyPrice = params.find(p => p.key === 'getEnergyFee')?.value ?? 100;
+                // Check if recipient needs activation (applies to all swaps)
+                let accountActivationFee = 0;
+                try {
+                    const recipientInfoResponse = await fetch(`${deps.config.VITE_TRON_NODE_URL}/wallet/getaccount`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ address: receiveAddress, visible: true }),
+                    });
+                    const recipientInfo = await recipientInfoResponse.json();
+                    const recipientExists = recipientInfo && Object.keys(recipientInfo).length > 1;
+                    if (!recipientExists) {
+                        accountActivationFee = 1_000_000; // 1 TRX
+                    }
+                }
+                catch {
+                    // Ignore activation check errors
+                }
+                // For native TRX swaps, Sun.io uses a contract call with value
+                // We need to estimate energy for the swap contract, not just bandwidth
+                if (isSellingNativeTrx) {
+                    try {
+                        // Sun.io contract owner provides most energy (~117k), users only pay ~2k
+                        // Use fixed 2k energy estimate instead of querying (which returns total 120k)
+                        const energyUsed = 2000; // User pays ~2k energy, contract covers the rest
+                        const energyFee = energyUsed * energyPrice; // No multiplier - contract provides energy
+                        // Estimate bandwidth for contract call (much larger than simple transfer)
+                        const bandwidthFee = 1100 * bandwidthPrice; // ~1100 bytes for contract call (with safety buffer)
+                        networkFeeCryptoBaseUnit = (0, utils_1.bn)(energyFee)
+                            .plus(bandwidthFee)
+                            .plus(accountActivationFee)
+                            .toFixed(0);
+                    }
+                    catch (estimationError) {
+                        // Fallback estimate: ~2k energy + ~1100 bytes bandwidth + activation fee
+                        const fallbackEnergyFee = 2000 * energyPrice;
+                        const fallbackBandwidthFee = 1100 * bandwidthPrice;
+                        networkFeeCryptoBaseUnit = (0, utils_1.bn)(fallbackEnergyFee)
+                            .plus(fallbackBandwidthFee)
+                            .plus(accountActivationFee)
+                            .toFixed(0);
+                    }
+                }
+                else {
+                    // For TRC-20 swaps through Sun.io router
+                    // Same as TRX: contract owner provides most energy, user pays ~2k
+                    // Sun.io provides ~217k energy, user pays ~2k
+                    const energyFee = 2000 * energyPrice;
+                    const bandwidthFee = 1100 * bandwidthPrice;
+                    networkFeeCryptoBaseUnit = (0, utils_1.bn)(energyFee)
+                        .plus(bandwidthFee)
+                        .plus(accountActivationFee)
+                        .toFixed(0);
+                }
+            }
+            catch (error) {
+                // For rates, fall back to '0' on estimation failure
+                // For quotes, let it error (required for accurate swap)
+                if (!isQuote) {
+                    networkFeeCryptoBaseUnit = '0';
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        const buyAmountCryptoBaseUnit = (0, utils_1.bn)(bestRoute.amountOut)
+            .times((0, utils_1.bn)(10).pow(buyAsset.precision))
+            .toFixed(0);
+        // Calculate protocol fees only for quotes
+        const protocolFeeCryptoBaseUnit = isQuote
+            ? (0, utils_1.bn)(bestRoute.fee).times(sellAmountIncludingProtocolFeesCryptoBaseUnit).toFixed(0)
+            : '0';
+        const buyAmountAfterFeesCryptoBaseUnit = buyAmountCryptoBaseUnit;
+        const rate = (0, utils_2.getInputOutputRate)({
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const trade = {
+            id: crypto.randomUUID(),
+            quoteOrRate: input.quoteOrRate,
+            rate,
+            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ?? constants_1.DEFAULT_SLIPPAGE_PERCENTAGE,
+            receiveAddress,
+            affiliateBps,
+            steps: [
+                {
+                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    feeData: {
+                        networkFeeCryptoBaseUnit,
+                        protocolFees: protocolFeeCryptoBaseUnit !== '0'
+                            ? {
+                                [sellAsset.assetId]: {
+                                    amountCryptoBaseUnit: protocolFeeCryptoBaseUnit,
+                                    requiresBalance: false,
+                                    asset: sellAsset,
+                                },
+                            }
+                            : {},
+                    },
+                    rate,
+                    source: types_1.SwapperName.Sunio,
+                    buyAsset,
+                    sellAsset,
+                    accountNumber,
+                    allowanceContract: constants_1.SUNIO_SMART_ROUTER_CONTRACT,
+                    estimatedExecutionTimeMs: undefined,
+                    ...(isQuote && {
+                        sunioTransactionMetadata: {
+                            route: bestRoute,
+                        },
+                    }),
+                },
+            ],
+            swapperName: types_1.SwapperName.Sunio,
+        };
+        return (0, monads_1.Ok)(trade);
+    }
+    catch (error) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `[Sun.io] Failed to get trade ${input.quoteOrRate}`,
+            code: types_1.TradeQuoteError.UnknownError,
+            cause: error,
+        }));
+    }
+}
+exports.getQuoteOrRate = getQuoteOrRate;

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

@@ -0,0 +1,4 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+export declare const isSupportedChainId: (chainId: string) => boolean;
+export declare const assetIdToTronToken: (assetId: AssetId) => string;
+export declare const isTronChainId: (chainId: string) => chainId is import("@shapeshiftoss/caip").ChainId;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTronChainId = exports.assetIdToTronToken = exports.isSupportedChainId = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const utils_1 = require("@shapeshiftoss/utils");
+const constants_1 = require("../constants");
+const isSupportedChainId = (chainId) => {
+    return constants_1.SUNIO_SUPPORTED_CHAIN_IDS.includes(chainId);
+};
+exports.isSupportedChainId = isSupportedChainId;
+const assetIdToTronToken = (assetId) => {
+    if ((0, utils_1.isToken)(assetId)) {
+        const { assetReference } = (0, caip_1.fromAssetId)(assetId);
+        return assetReference;
+    }
+    return constants_1.SUNIO_TRON_NATIVE_ADDRESS;
+};
+exports.assetIdToTronToken = assetIdToTronToken;
+const isTronChainId = (chainId) => {
+    return chainId === caip_1.tronChainId;
+};
+exports.isTronChainId = isTronChainId;

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

@@ -0,0 +1,6 @@
+export declare const sunioServiceFactory: () => {
+    get: <T = any>(url: string, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("../../..").SwapErrorRight>>;
+    post: <T_1 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_1, any, {}>, import("../../..").SwapErrorRight>>;
+    delete: <T_2 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_2, any, {}>, import("../../..").SwapErrorRight>>;
+};
+export type SunioService = ReturnType<typeof sunioServiceFactory>;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sunioServiceFactory = void 0;
+const utils_1 = require("../../../utils");
+const maxAge = 5 * 1000;
+const cachedUrls = ['/swap/router'];
+const sunioServiceFactory = () => {
+    const axiosConfig = {
+        timeout: 10000,
+        headers: {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+        },
+    };
+    const serviceBase = (0, utils_1.createCache)(maxAge, cachedUrls, axiosConfig);
+    return (0, utils_1.makeSwapperAxiosServiceMonadic)(serviceBase);
+};
+exports.sunioServiceFactory = sunioServiceFactory;

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

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

package/dist/cjs/swappers/ThorchainSwapper/ThorchainSwapper.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.thorchainSwapper = void 0;
+const utils_1 = require("../../utils");
+exports.thorchainSwapper = {
+    executeEvmTransaction: utils_1.executeEvmTransaction,
+    executeCosmosSdkTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
+    executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
+    executeTronTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
+};

package/dist/cjs/swappers/ThorchainSwapper/constants.d.ts

@@ -0,0 +1,7 @@
+import type { SwapSource } from '../../types';
+export declare const THORCHAIN_PRECISION = 8;
+export declare const THORCHAIN_AFFILIATE_NAME = "ss";
+export declare const THORCHAIN_SUPPORTED_CHAIN_IDS: import("@shapeshiftoss/caip").ChainId[];
+export declare const THORCHAIN_STREAM_SWAP_SOURCE: SwapSource;
+export declare const THORCHAIN_LONGTAIL_SWAP_SOURCE: SwapSource;
+export declare const THORCHAIN_LONGTAIL_STREAMING_SWAP_SOURCE: SwapSource;

package/dist/cjs/swappers/ThorchainSwapper/constants.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.THORCHAIN_LONGTAIL_STREAMING_SWAP_SOURCE = exports.THORCHAIN_LONGTAIL_SWAP_SOURCE = exports.THORCHAIN_STREAM_SWAP_SOURCE = exports.THORCHAIN_SUPPORTED_CHAIN_IDS = exports.THORCHAIN_AFFILIATE_NAME = exports.THORCHAIN_PRECISION = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const types_1 = require("../../types");
+const poolAssetHelpers_1 = require("./utils/poolAssetHelpers/poolAssetHelpers");
+exports.THORCHAIN_PRECISION = 8;
+exports.THORCHAIN_AFFILIATE_NAME = 'ss';
+exports.THORCHAIN_SUPPORTED_CHAIN_IDS = [
+    ...new Set(Object.keys(poolAssetHelpers_1.assetIdToThorPoolAssetIdMap).map(assetId => (0, caip_1.fromAssetId)(assetId).chainId)),
+];
+exports.THORCHAIN_STREAM_SWAP_SOURCE = `${types_1.SwapperName.Thorchain} • Streaming`;
+exports.THORCHAIN_LONGTAIL_SWAP_SOURCE = `${types_1.SwapperName.Thorchain} • Long-tail`;
+exports.THORCHAIN_LONGTAIL_STREAMING_SWAP_SOURCE = `${types_1.SwapperName.Thorchain} • Long-tail streaming`;

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

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

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.thorchainApi = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const thorchain_utils_1 = require("../../thorchain-utils");
+const types_1 = require("../../types");
+const utils_1 = require("../../utils");
+const getTradeQuote_1 = require("./getTradeQuote/getTradeQuote");
+const getTradeRate_1 = require("./getTradeRate/getTradeRate");
+const swapperName = types_1.SwapperName.Thorchain;
+exports.thorchainApi = {
+    getTradeRate: getTradeRate_1.getTradeRate,
+    getTradeQuote: getTradeQuote_1.getTradeQuote,
+    getUnsignedEvmTransaction: input => thorchain_utils_1.evm.getUnsignedEvmTransaction(input, swapperName),
+    getEvmTransactionFees: input => thorchain_utils_1.evm.getEvmTransactionFees(input, swapperName),
+    getUnsignedUtxoTransaction: input => thorchain_utils_1.utxo.getUnsignedUtxoTransaction(input, swapperName),
+    getUtxoTransactionFees: input => thorchain_utils_1.utxo.getUtxoTransactionFees(input, swapperName),
+    getUnsignedTronTransaction: input => thorchain_utils_1.tron.getUnsignedTronTransaction(input, swapperName),
+    getTronTransactionFees: input => thorchain_utils_1.tron.getTronTransactionFees(input, swapperName),
+    getUnsignedCosmosSdkTransaction: async ({ tradeQuote, stepIndex, from, config, assertGetCosmosSdkChainAdapter, }) => {
+        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const { memo } = tradeQuote;
+        if (!memo)
+            throw new Error('Memo is required');
+        const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
+        const { accountNumber, sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset, feeData } = step;
+        const gas = feeData.chainSpecific.estimatedGasCryptoBaseUnit;
+        const fee = feeData.networkFeeCryptoBaseUnit ?? '0';
+        switch (sellAsset.assetId) {
+            case caip_1.thorchainAssetId:
+            case caip_1.rujiAssetId:
+            case caip_1.tcyAssetId: {
+                const coin = (() => {
+                    if (sellAsset.assetId === caip_1.tcyAssetId)
+                        return 'THOR.TCY';
+                    if (sellAsset.assetId === caip_1.rujiAssetId)
+                        return 'THOR.RUJI';
+                    return 'THOR.RUNE';
+                })();
+                const adapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
+                const { txToSign } = await adapter.buildDepositTransaction({
+                    accountNumber,
+                    from,
+                    value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    memo,
+                    chainSpecific: {
+                        gas,
+                        fee,
+                        coin,
+                    },
+                });
+                return txToSign;
+            }
+            case caip_1.cosmosAssetId: {
+                const adapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
+                const url = `${config.VITE_THORCHAIN_NODE_URL}/thorchain`;
+                const data = await (0, thorchain_utils_1.getInboundAddressDataForChain)(url, caip_1.cosmosAssetId, true, swapperName);
+                if (data.isErr())
+                    throw data.unwrapErr();
+                const { address: vault } = data.unwrap();
+                const { txToSign } = await adapter.buildSendApiTransaction({
+                    accountNumber,
+                    from,
+                    to: vault,
+                    value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    memo,
+                    chainSpecific: { gas, fee },
+                });
+                return txToSign;
+            }
+            default:
+                throw Error(`Unsupported sellAsset: ${sellAsset.assetId}`);
+        }
+    },
+    getCosmosSdkTransactionFees: input => thorchain_utils_1.cosmossdk.getCosmosSdkTransactionFees(input),
+    checkTradeStatus: input => {
+        const { config } = input;
+        const nodeUrl = `${config.VITE_THORCHAIN_NODE_URL}/thorchain`;
+        const apiUrl = `${config.VITE_UNCHAINED_THORCHAIN_HTTP_URL}/api/v1`;
+        return (0, thorchain_utils_1.checkTradeStatus)({ ...input, nodeUrl, apiUrl, nativeChain: 'THOR' });
+    },
+};