@shapeshiftoss/swapper 17.6.6 → 17.6.8

package/dist/cjs/thorchain-utils/getL1RateOrQuote.js

@@ -0,0 +1,394 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getL1RateOrQuote = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const adapters = __importStar(require("@shapeshiftoss/chain-adapters"));
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const tronweb_1 = require("tronweb");
+const uuid_1 = require("uuid");
+const index_1 = require("../index");
+const types_1 = require("../types");
+const utils_2 = require("../utils");
+const evm = __importStar(require("./evm"));
+const getLimitWithManualSlippage_1 = require("./getLimitWithManualSlippage/getLimitWithManualSlippage");
+const getQuote_1 = require("./getQuote");
+const index_2 = require("./index");
+const tron = __importStar(require("./tron"));
+const utxo = __importStar(require("./utxo"));
+const SAFE_GAS_LIMIT = '100000'; // depositWithExpiry()
+const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType, swapperName) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmountCryptoBaseUnit, accountNumber, receiveAddress, affiliateBps: requestedAffiliateBps, } = input;
+    const { config, assertGetEvmChainAdapter, assertGetUtxoChainAdapter, assertGetCosmosSdkChainAdapter, } = deps;
+    // "NativePrecision" is intended to indicate the base unit precision of the asset
+    // for the corresponding swapper network (THORChain or MAYAChain)
+    // (CACAO = 10, everything else = 8)
+    const sellAssetNativePrecision = (0, index_2.getNativePrecision)(sellAsset.assetId, swapperName);
+    const buyAssetNativePrecision = (0, index_2.getNativePrecision)(buyAsset.assetId, swapperName);
+    const { chainNamespace } = (0, caip_1.fromAssetId)(sellAsset.assetId);
+    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
+        (0, index_1.getDefaultSlippageDecimalPercentageForSwapper)(swapperName);
+    const inputSlippageBps = (0, utils_1.convertDecimalPercentageToBasisPoints)(slippageTolerancePercentageDecimal);
+    const baseQuoteArgs = {
+        sellAsset,
+        buyAssetId: buyAsset.assetId,
+        sellAmountCryptoBaseUnit,
+        receiveAddress,
+        affiliateBps: requestedAffiliateBps,
+        swapperName,
+    };
+    const maybeSwapQuote = await (0, getQuote_1.getQuote)({ ...baseQuoteArgs, streaming: false }, deps);
+    const maybeStreamingSwapQuote = await (0, getQuote_1.getQuote)({ ...baseQuoteArgs, streaming: true, streamingInterval }, deps);
+    if (maybeSwapQuote.isErr() && maybeStreamingSwapQuote.isErr()) {
+        return (0, monads_1.Err)(maybeSwapQuote.unwrapErr());
+    }
+    const swapQuote = maybeSwapQuote.isOk() ? maybeSwapQuote.unwrap() : undefined;
+    const streamingSwapQuote = maybeStreamingSwapQuote.isOk()
+        ? maybeStreamingSwapQuote.unwrap()
+        : undefined;
+    const getRouteValues = (quote, isStreaming) => {
+        const source = (0, index_2.getSwapSource)(tradeType, isStreaming, swapperName);
+        return {
+            source,
+            quote,
+            expectedAmountOutThorBaseUnit: (0, utils_1.bnOrZero)(quote.expected_amount_out).toFixed(),
+            isStreaming,
+            affiliateBps: quote.fees.affiliate === '0' ? '0' : requestedAffiliateBps,
+            // always use auto stream slippage limit (0 limit = 5bps - 50bps, sometimes up to 100bps)
+            // see: https://discord.com/channels/838986635756044328/1166265575941619742/1166500062101250100
+            slippageBps: isStreaming ? (0, utils_1.bn)(0) : inputSlippageBps,
+            estimatedExecutionTimeMs: quote.total_swap_seconds
+                ? 1000 * quote.total_swap_seconds
+                : undefined,
+        };
+    };
+    const perRouteValues = [];
+    if (swapQuote)
+        perRouteValues.push(getRouteValues(swapQuote, false));
+    if (streamingSwapQuote)
+        perRouteValues.push(getRouteValues(streamingSwapQuote, true));
+    const recommendedMinAmountIn = swapQuote?.recommended_min_amount_in ?? streamingSwapQuote?.recommended_min_amount_in;
+    // recommended_min_amount_in should be the same value for both types of swaps
+    const recommendedMinimumCryptoBaseUnit = recommendedMinAmountIn
+        ? (0, utils_1.convertPrecision)({
+            value: recommendedMinAmountIn,
+            inputExponent: sellAssetNativePrecision,
+            outputExponent: sellAsset.precision,
+        }).toFixed()
+        : '0';
+    const getRouteBuyAmountBeforeFeesCryptoBaseUnit = (quote) => {
+        const buyAmountBeforeFeesCryptoThorPrecision = (0, utils_1.bn)(quote.expected_amount_out).plus(quote.fees.total);
+        return (0, utils_1.toBaseUnit)((0, utils_1.fromBaseUnit)(buyAmountBeforeFeesCryptoThorPrecision, buyAssetNativePrecision), buyAsset.precision);
+    };
+    const getProtocolFees = (quote) => {
+        // Fees consist of liquidity, outbound, and affiliate fees
+        // For the purpose of displaying protocol fees to the user, we don't need the latter
+        // The reason for that is the affiliate fee is shown as its own "ShapeShift fee" section
+        // Including the affiliate fee here would result in the protocol fee being wrong, as affiliate fees would be
+        // double accounted for both in protocol fees, and affiliate fee
+        const buyAssetTradeFeeBuyAssetCryptoThorPrecision = (0, utils_1.bnOrZero)(quote.fees.total).minus(quote.fees.affiliate);
+        const buyAssetTradeFeeBuyAssetCryptoBaseUnit = (0, utils_1.convertPrecision)({
+            value: buyAssetTradeFeeBuyAssetCryptoThorPrecision,
+            inputExponent: buyAssetNativePrecision,
+            outputExponent: buyAsset.precision,
+        });
+        const protocolFees = {};
+        if (!buyAssetTradeFeeBuyAssetCryptoBaseUnit.isZero()) {
+            protocolFees[buyAsset.assetId] = {
+                amountCryptoBaseUnit: buyAssetTradeFeeBuyAssetCryptoBaseUnit.toString(),
+                requiresBalance: false,
+                asset: buyAsset,
+            };
+        }
+        return protocolFees;
+    };
+    const getMemo = (route) => {
+        if (input.quoteOrRate === 'rate')
+            return '';
+        if (!route.quote.memo)
+            throw new Error('no memo provided');
+        // always use auto stream quote memo (0 limit = 5bps - 50bps, sometimes up to 100bps)
+        // see: https://discord.com/channels/838986635756044328/1166265575941619742/1166500062101250100
+        if (route.isStreaming)
+            return (0, index_2.assertAndProcessMemo)(route.quote.memo, (0, index_2.getAffiliate)(swapperName));
+        const limitWithManualSlippage = (0, getLimitWithManualSlippage_1.getLimitWithManualSlippage)({
+            expectedAmountOutThorBaseUnit: route.expectedAmountOutThorBaseUnit,
+            slippageBps: route.slippageBps,
+        });
+        return (0, index_2.addLimitToMemo)({
+            memo: route.quote.memo,
+            limit: limitWithManualSlippage,
+            affilate: (0, index_2.getAffiliate)(swapperName),
+        });
+    };
+    const makeThorTradeRateOrQuote = ({ route, memo, allowanceContract, feeData, data, router, vault, }) => {
+        const buyAmountAfterFeesCryptoBaseUnit = (0, utils_1.convertPrecision)({
+            value: route.expectedAmountOutThorBaseUnit,
+            inputExponent: buyAssetNativePrecision,
+            outputExponent: buyAsset.precision,
+        }).toFixed();
+        const rate = (0, utils_2.getInputOutputRate)({
+            sellAmountCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const slippage = route.isStreaming ? undefined : slippageTolerancePercentageDecimal;
+        const buyAmountBeforeFeesCryptoBaseUnit = getRouteBuyAmountBeforeFeesCryptoBaseUnit(route.quote);
+        return {
+            id: (0, uuid_1.v4)(),
+            quoteOrRate: input.quoteOrRate,
+            memo,
+            receiveAddress,
+            affiliateBps: route.affiliateBps,
+            isStreaming: route.isStreaming,
+            recommendedMinimumCryptoBaseUnit,
+            slippageTolerancePercentageDecimal: slippage,
+            rate,
+            data,
+            router,
+            vault,
+            expiry: route.quote.expiry,
+            tradeType,
+            swapperName,
+            steps: [
+                {
+                    estimatedExecutionTimeMs: route.estimatedExecutionTimeMs,
+                    rate,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmountCryptoBaseUnit,
+                    buyAmountBeforeFeesCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit,
+                    source: route.source,
+                    buyAsset,
+                    sellAsset,
+                    accountNumber,
+                    allowanceContract,
+                    feeData,
+                    thorchainSpecific: {
+                        maxStreamingQuantity: route.quote.max_streaming_quantity,
+                    },
+                },
+            ],
+        };
+    };
+    switch (chainNamespace) {
+        case caip_1.CHAIN_NAMESPACE.Evm: {
+            const { supportsEIP1559 } = input;
+            const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+            const maybeRoutes = await Promise.allSettled(perRouteValues.map(async (route) => {
+                const memo = getMemo(route);
+                const { data, router, vault } = await evm.getThorTxData({
+                    sellAsset,
+                    sellAmountCryptoBaseUnit,
+                    memo,
+                    expiry: route.quote.expiry,
+                    config,
+                    swapperName,
+                });
+                const { average } = await adapter.getGasFeeData();
+                const networkFeeCryptoBaseUnit = adapters.evm.calcNetworkFeeCryptoBaseUnit({
+                    ...average,
+                    supportsEIP1559,
+                    gasLimit: SAFE_GAS_LIMIT,
+                });
+                return makeThorTradeRateOrQuote({
+                    route,
+                    memo,
+                    allowanceContract: router,
+                    data,
+                    router,
+                    vault,
+                    feeData: {
+                        protocolFees: getProtocolFees(route.quote),
+                        networkFeeCryptoBaseUnit,
+                    },
+                });
+            }));
+            const routes = maybeRoutes.filter(utils_1.isFulfilled).map(maybeRoute => maybeRoute.value);
+            if (!routes.length)
+                return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                    message: 'Unable to create any routes',
+                    code: types_1.TradeQuoteError.UnsupportedTradePair,
+                    cause: maybeRoutes.filter(utils_1.isRejected).map(maybeRoute => maybeRoute.reason),
+                }));
+            return (0, monads_1.Ok)(routes);
+        }
+        case caip_1.CHAIN_NAMESPACE.Utxo: {
+            const { xpub = '' } = input;
+            const sellAdapter = assertGetUtxoChainAdapter(sellAsset.chainId);
+            const maybeRoutes = await Promise.allSettled(perRouteValues.map(async (route) => {
+                const memo = getMemo(route);
+                const { vault } = await utxo.getThorTxData({ sellAsset, config, swapperName });
+                const feeData = await (async () => {
+                    const protocolFees = getProtocolFees(route.quote);
+                    // This is a rate without a wallet connected, so we can't get fees
+                    if (!xpub)
+                        return { networkFeeCryptoBaseUnit: undefined, protocolFees };
+                    const { fast } = await sellAdapter.getFeeData({
+                        to: vault,
+                        value: sellAmountCryptoBaseUnit,
+                        chainSpecific: { pubkey: xpub, opReturnData: memo },
+                    });
+                    return {
+                        networkFeeCryptoBaseUnit: fast.txFee,
+                        protocolFees,
+                        chainSpecific: {
+                            satsPerByte: fast.chainSpecific.satoshiPerByte,
+                        },
+                    };
+                })();
+                return makeThorTradeRateOrQuote({
+                    route,
+                    allowanceContract: '0x0',
+                    memo,
+                    feeData,
+                });
+            }));
+            const routes = maybeRoutes.filter(utils_1.isFulfilled).map(maybeRoute => maybeRoute.value);
+            if (!routes.length)
+                return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                    message: 'Unable to create any routes',
+                    code: types_1.TradeQuoteError.UnsupportedTradePair,
+                    cause: maybeRoutes.filter(utils_1.isRejected).map(maybeRoute => maybeRoute.reason),
+                }));
+            return (0, monads_1.Ok)(routes);
+        }
+        case caip_1.CHAIN_NAMESPACE.CosmosSdk: {
+            const cosmosChainAdapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
+            const { fast } = await cosmosChainAdapter.getFeeData({});
+            return (0, monads_1.Ok)(perRouteValues.map((route) => {
+                return makeThorTradeRateOrQuote({
+                    route,
+                    memo: getMemo(route),
+                    allowanceContract: '0x0',
+                    feeData: {
+                        networkFeeCryptoBaseUnit: fast.txFee,
+                        protocolFees: getProtocolFees(route.quote),
+                        chainSpecific: {
+                            estimatedGasCryptoBaseUnit: fast.chainSpecific.gasLimit,
+                        },
+                    },
+                });
+            }));
+        }
+        case caip_1.CHAIN_NAMESPACE.Solana: {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: 'Solana is not supported',
+                code: types_1.TradeQuoteError.UnsupportedTradePair,
+            }));
+        }
+        case caip_1.CHAIN_NAMESPACE.Tron: {
+            const maybeRoutes = await Promise.allSettled(perRouteValues.map(async (route) => {
+                const memo = getMemo(route);
+                let networkFeeCryptoBaseUnit = undefined;
+                // Calculate fees for rates when we have a receive address (wallet connected)
+                if (input.quoteOrRate === 'rate' && input.receiveAddress) {
+                    try {
+                        const { sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
+                        const contractAddress = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
+                        // Get vault address
+                        const { vault } = await tron.getThorTxData({ sellAsset, config, swapperName });
+                        // Estimate fees using the receive address for accurate energy calculation
+                        const tronWeb = new tronweb_1.TronWeb({ fullHost: deps.config.VITE_TRON_NODE_URL });
+                        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;
+                        let totalFee = 0;
+                        if (contractAddress) {
+                            // TRC20: Estimate energy with actual recipient
+                            try {
+                                const result = await tronWeb.transactionBuilder.triggerConstantContract(contractAddress, 'transfer(address,uint256)', {}, [
+                                    { type: 'address', value: vault },
+                                    { type: 'uint256', value: sellAmountIncludingProtocolFeesCryptoBaseUnit },
+                                ], input.receiveAddress);
+                                const energyUsed = result.energy_used ?? 65000;
+                                const energyFee = energyUsed * energyPrice * 1.5; // 1.5x safety margin
+                                const bandwidthFee = 276 * bandwidthPrice; // TRC20 bandwidth
+                                totalFee = Math.ceil(energyFee + bandwidthFee);
+                            }
+                            catch {
+                                // Fallback: Conservative estimate
+                                totalFee = 13_000_000; // 13 TRX worst case
+                            }
+                        }
+                        else {
+                            // TRX transfer bandwidth: Base tx + memo bytes
+                            const baseBytes = 198;
+                            const memoBytes = route.quote.memo
+                                ? Buffer.from(route.quote.memo, 'utf8').length
+                                : 0;
+                            const totalBandwidth = baseBytes + memoBytes;
+                            totalFee = totalBandwidth * bandwidthPrice;
+                        }
+                        networkFeeCryptoBaseUnit = String(totalFee);
+                    }
+                    catch {
+                        // Leave as undefined if estimation fails
+                    }
+                }
+                // For quotes, fees will be calculated in getTronTransactionFees when executing
+                return Promise.resolve(makeThorTradeRateOrQuote({
+                    route,
+                    allowanceContract: '0x0',
+                    memo,
+                    feeData: {
+                        networkFeeCryptoBaseUnit,
+                        protocolFees: getProtocolFees(route.quote),
+                    },
+                }));
+            }));
+            const routes = maybeRoutes.filter(utils_1.isFulfilled).map(maybeRoute => maybeRoute.value);
+            if (!routes.length)
+                return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                    message: 'Unable to create any routes',
+                    code: types_1.TradeQuoteError.UnsupportedTradePair,
+                    cause: maybeRoutes.filter(utils_1.isRejected).map(maybeRoute => maybeRoute.reason),
+                }));
+            return (0, monads_1.Ok)(routes);
+        }
+        case caip_1.CHAIN_NAMESPACE.Sui: {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: 'SUI is not supported',
+                code: types_1.TradeQuoteError.UnsupportedTradePair,
+            }));
+        }
+        case caip_1.CHAIN_NAMESPACE.Near: {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: 'NEAR is not supported',
+                code: types_1.TradeQuoteError.UnsupportedTradePair,
+            }));
+        }
+        case caip_1.CHAIN_NAMESPACE.Starknet: {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: 'Starknet is not supported',
+                code: types_1.TradeQuoteError.UnsupportedTradePair,
+            }));
+        }
+        default:
+            return (0, utils_1.assertUnreachable)(chainNamespace);
+    }
+};
+exports.getL1RateOrQuote = getL1RateOrQuote;

package/dist/cjs/thorchain-utils/getLatestThorTxStatusMessage.d.ts

@@ -0,0 +1,2 @@
+import type { ThorNodeStatusResponseSuccess } from './types';
+export declare const getLatestThorTxStatusMessage: (response: ThorNodeStatusResponseSuccess, hasOutboundTx: boolean) => string | undefined;

package/dist/cjs/thorchain-utils/getLatestThorTxStatusMessage.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLatestThorTxStatusMessage = void 0;
+const utils_1 = require("@shapeshiftoss/utils");
+const pretty_ms_1 = __importDefault(require("pretty-ms"));
+const types_1 = require("./types");
+const getLatestThorTxStatusMessage = (response, hasOutboundTx) => {
+    const stages_reverse_ordered = [
+        'outbound_signed',
+        'outbound_delay',
+        'swap_finalised',
+        'swap_status',
+        'inbound_finalised',
+        'inbound_confirmation_counted',
+        'inbound_observed',
+    ];
+    for (const key of stages_reverse_ordered) {
+        switch (key) {
+            case 'inbound_observed': {
+                const obj = response.stages[key];
+                return obj.completed
+                    ? types_1.ThorchainStatusMessage.InboundObserved
+                    : types_1.ThorchainStatusMessage.InboundObservingPending;
+            }
+            case 'inbound_confirmation_counted': {
+                const obj = response.stages[key];
+                if (obj === undefined)
+                    continue;
+                return obj.completed
+                    ? types_1.ThorchainStatusMessage.InboundConfirmationCounted
+                    : types_1.ThorchainStatusMessage.InboundConfirmationPending;
+            }
+            case 'inbound_finalised': {
+                const obj = response.stages[key];
+                if (obj === undefined)
+                    continue;
+                return obj.completed
+                    ? types_1.ThorchainStatusMessage.InboundFinalized
+                    : types_1.ThorchainStatusMessage.InboundFinalizationPending;
+            }
+            case 'swap_status': {
+                const swapStatusStage = response.stages[key];
+                const inboundFinalizedStage = response.stages.inbound_finalised;
+                if (swapStatusStage === undefined || inboundFinalizedStage === undefined)
+                    continue;
+                if (!inboundFinalizedStage.completed)
+                    continue;
+                if (swapStatusStage.pending)
+                    return types_1.ThorchainStatusMessage.SwapPending;
+                return hasOutboundTx
+                    ? types_1.ThorchainStatusMessage.SwapCompleteAwaitingOutbound
+                    : types_1.ThorchainStatusMessage.SwapCompleteAwaitingDestination;
+            }
+            case 'swap_finalised': {
+                // to be deprecated in favor of swap_status (see https://thornode.ninerealms.com/thorchain/doc/)
+                continue;
+            }
+            case 'outbound_delay': {
+                const obj = response.stages[key];
+                if (obj === undefined || obj.completed)
+                    continue;
+                return obj.remaining_delay_seconds
+                    ? // poor man's i18n
+                        types_1.ThorchainStatusMessage.OutboundDelayTimeRemaining.replace('{timeRemaining}', (0, pretty_ms_1.default)(obj.remaining_delay_seconds * 100))
+                    : types_1.ThorchainStatusMessage.OutboundDelayPending;
+            }
+            case 'outbound_signed': {
+                const obj = response.stages[key];
+                if (obj === undefined)
+                    continue;
+                return obj.completed
+                    ? types_1.ThorchainStatusMessage.OutboundSigned
+                    : types_1.ThorchainStatusMessage.OutboundScheduled;
+            }
+            default:
+                return (0, utils_1.assertUnreachable)(key);
+        }
+    }
+};
+exports.getLatestThorTxStatusMessage = getLatestThorTxStatusMessage;

package/dist/cjs/thorchain-utils/getLimitWithManualSlippage/getLimitWithManualSlippage.d.ts

@@ -0,0 +1,5 @@
+import BigNumber from 'bignumber.js';
+export declare const getLimitWithManualSlippage: ({ expectedAmountOutThorBaseUnit, slippageBps, }: {
+    expectedAmountOutThorBaseUnit: string;
+    slippageBps: BigNumber.Value;
+}) => string;

package/dist/cjs/thorchain-utils/getLimitWithManualSlippage/getLimitWithManualSlippage.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLimitWithManualSlippage = void 0;
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const utils_1 = require("@shapeshiftoss/utils");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const getLimitWithManualSlippage = ({ expectedAmountOutThorBaseUnit, slippageBps, }) => {
+    const limitWithManualSlippage = (0, utils_1.subtractBasisPointAmount)((0, chain_adapters_1.bn)(expectedAmountOutThorBaseUnit).toFixed(0, bignumber_js_1.default.ROUND_DOWN), slippageBps, bignumber_js_1.default.ROUND_DOWN);
+    return limitWithManualSlippage;
+};
+exports.getLimitWithManualSlippage = getLimitWithManualSlippage;

package/dist/cjs/thorchain-utils/getLimitWithManualSlippage/getLimitWithManualSlippage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/thorchain-utils/getLimitWithManualSlippage/getLimitWithManualSlippage.test.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const getLimitWithManualSlippage_1 = require("./getLimitWithManualSlippage");
+(0, vitest_1.describe)('getLimitWithManualSlippage', () => {
+    (0, vitest_1.it)('should remove slippage from expected amount out', () => {
+        const amountOut = '100';
+        const expectedLimitWithManualSlippage = '50';
+        const slippageBps = 5000; // 50%
+        const limitWithManualSlippage = (0, getLimitWithManualSlippage_1.getLimitWithManualSlippage)({
+            expectedAmountOutThorBaseUnit: amountOut,
+            slippageBps,
+        });
+        (0, vitest_1.expect)(limitWithManualSlippage).toBe(expectedLimitWithManualSlippage);
+    });
+});

package/dist/cjs/thorchain-utils/getPoolDetails.d.ts

@@ -0,0 +1,20 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../types';
+import { SwapperName } from '../types';
+import type { ThornodePoolResponse } from './types';
+type GetPoolDetailsArgs = {
+    buyAsset: Asset;
+    sellAsset: Asset;
+    url: string;
+    swapperName: SwapperName;
+};
+type PoolDetails = {
+    buyPool?: ThornodePoolResponse;
+    buyPoolId?: string;
+    sellPool?: ThornodePoolResponse;
+    sellPoolId?: string;
+    streamingInterval: number;
+};
+export declare const getPoolDetails: (args: GetPoolDetailsArgs) => Promise<Result<PoolDetails, SwapErrorRight>>;
+export {};

package/dist/cjs/thorchain-utils/getPoolDetails.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPoolDetails = void 0;
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const types_1 = require("../types");
+const index_1 = require("./index");
+const service_1 = require("./service");
+const getPoolDetails = async (args) => {
+    const { buyAsset, sellAsset, url, swapperName } = args;
+    const res = await service_1.thorService.get(url);
+    if (res.isErr())
+        return (0, monads_1.Err)(res.unwrapErr());
+    const { data: poolsResponse } = res.unwrap();
+    const buyPoolId = (0, index_1.getPoolAssetId)({ assetId: buyAsset.assetId, swapperName });
+    const sellPoolId = (0, index_1.getPoolAssetId)({ assetId: sellAsset.assetId, swapperName });
+    const sellPool = poolsResponse.find(pool => pool.asset === sellPoolId);
+    const buyPool = poolsResponse.find(pool => pool.asset === buyPoolId);
+    const streamingInterval = (() => {
+        // https://discord.com/channels/915368890475880468/1105576530354118706/1270235165062594560
+        if (swapperName === types_1.SwapperName.Mayachain)
+            return 3;
+        const sellAssetDepthBps = (() => {
+            // Sell pool is the same as buy pool if selling native fee asset
+            if ((0, index_1.isNativeAsset)(sellAsset.assetId, swapperName))
+                return buyPool?.derived_depth_bps;
+            return sellPool?.derived_depth_bps;
+        })();
+        const buyAssetDepthBps = (() => {
+            // Buy pool is the same as sell pool if buying native fee asset
+            if ((0, index_1.isNativeAsset)(buyAsset.assetId, swapperName))
+                return sellPool?.derived_depth_bps;
+            return buyPool?.derived_depth_bps;
+        })();
+        if (sellAssetDepthBps && buyAssetDepthBps) {
+            const swapDepthBps = (0, utils_1.bn)(sellAssetDepthBps).plus(buyAssetDepthBps).div(2);
+            // Low health for the pools of this swap - use a longer streaming interval
+            if (swapDepthBps.lt(5000))
+                return 10;
+            // Moderate health for the pools of this swap - use a moderate streaming interval
+            if (swapDepthBps.lt(9000) && swapDepthBps.gte(5000))
+                return 5;
+            // Pool is at 90%+ health - use a 1 block streaming interval
+            return 1;
+        }
+        // Default streaming interval if derived depth bps are not available
+        return 10;
+    })();
+    return (0, monads_1.Ok)({ buyPoolId, buyPool, sellPoolId, sellPool, streamingInterval });
+};
+exports.getPoolDetails = getPoolDetails;

package/dist/cjs/thorchain-utils/getQuote.d.ts

@@ -0,0 +1,21 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight, SwapperDeps, SwapperName } from '../types';
+import type { ThornodeQuoteResponseSuccess } from './types';
+type GetQuoteArgs = {
+    sellAsset: Asset;
+    buyAssetId: AssetId;
+    sellAmountCryptoBaseUnit: string;
+    receiveAddress: string | undefined;
+    affiliateBps: string;
+    swapperName: SwapperName;
+} & ({
+    streaming: true;
+    streamingInterval: number;
+} | {
+    streaming?: false;
+    streamingInterval?: never;
+});
+export declare const getQuote: (input: GetQuoteArgs, deps: SwapperDeps) => Promise<Result<ThornodeQuoteResponseSuccess, SwapErrorRight>>;
+export {};