@shapeshiftoss/swapper 17.6.6 → 17.6.8

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

@@ -0,0 +1,367 @@
+import { CHAIN_NAMESPACE, fromAssetId } from '@shapeshiftoss/caip';
+import * as adapters from '@shapeshiftoss/chain-adapters';
+import { assertUnreachable, bn, bnOrZero, contractAddressOrUndefined, convertDecimalPercentageToBasisPoints, convertPrecision, fromBaseUnit, isFulfilled, isRejected, toBaseUnit, } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { TronWeb } from 'tronweb';
+import { v4 as uuid } from 'uuid';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../index.js';
+import { TradeQuoteError } from '../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../utils.js';
+import * as evm from './evm/index.js';
+import { getLimitWithManualSlippage } from './getLimitWithManualSlippage/getLimitWithManualSlippage.js';
+import { getQuote } from './getQuote.js';
+import { addLimitToMemo, assertAndProcessMemo, getAffiliate, getNativePrecision, getSwapSource, } from './index.js';
+import * as tron from './tron/index.js';
+import * as utxo from './utxo/index.js';
+const SAFE_GAS_LIMIT = '100000'; // depositWithExpiry()
+export 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 = getNativePrecision(sellAsset.assetId, swapperName);
+    const buyAssetNativePrecision = getNativePrecision(buyAsset.assetId, swapperName);
+    const { chainNamespace } = fromAssetId(sellAsset.assetId);
+    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
+        getDefaultSlippageDecimalPercentageForSwapper(swapperName);
+    const inputSlippageBps = convertDecimalPercentageToBasisPoints(slippageTolerancePercentageDecimal);
+    const baseQuoteArgs = {
+        sellAsset,
+        buyAssetId: buyAsset.assetId,
+        sellAmountCryptoBaseUnit,
+        receiveAddress,
+        affiliateBps: requestedAffiliateBps,
+        swapperName,
+    };
+    const maybeSwapQuote = await getQuote({ ...baseQuoteArgs, streaming: false }, deps);
+    const maybeStreamingSwapQuote = await getQuote({ ...baseQuoteArgs, streaming: true, streamingInterval }, deps);
+    if (maybeSwapQuote.isErr() && maybeStreamingSwapQuote.isErr()) {
+        return Err(maybeSwapQuote.unwrapErr());
+    }
+    const swapQuote = maybeSwapQuote.isOk() ? maybeSwapQuote.unwrap() : undefined;
+    const streamingSwapQuote = maybeStreamingSwapQuote.isOk()
+        ? maybeStreamingSwapQuote.unwrap()
+        : undefined;
+    const getRouteValues = (quote, isStreaming) => {
+        const source = getSwapSource(tradeType, isStreaming, swapperName);
+        return {
+            source,
+            quote,
+            expectedAmountOutThorBaseUnit: 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 ? 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
+        ? convertPrecision({
+            value: recommendedMinAmountIn,
+            inputExponent: sellAssetNativePrecision,
+            outputExponent: sellAsset.precision,
+        }).toFixed()
+        : '0';
+    const getRouteBuyAmountBeforeFeesCryptoBaseUnit = (quote) => {
+        const buyAmountBeforeFeesCryptoThorPrecision = bn(quote.expected_amount_out).plus(quote.fees.total);
+        return toBaseUnit(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 = bnOrZero(quote.fees.total).minus(quote.fees.affiliate);
+        const buyAssetTradeFeeBuyAssetCryptoBaseUnit = 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 assertAndProcessMemo(route.quote.memo, getAffiliate(swapperName));
+        const limitWithManualSlippage = getLimitWithManualSlippage({
+            expectedAmountOutThorBaseUnit: route.expectedAmountOutThorBaseUnit,
+            slippageBps: route.slippageBps,
+        });
+        return addLimitToMemo({
+            memo: route.quote.memo,
+            limit: limitWithManualSlippage,
+            affilate: getAffiliate(swapperName),
+        });
+    };
+    const makeThorTradeRateOrQuote = ({ route, memo, allowanceContract, feeData, data, router, vault, }) => {
+        const buyAmountAfterFeesCryptoBaseUnit = convertPrecision({
+            value: route.expectedAmountOutThorBaseUnit,
+            inputExponent: buyAssetNativePrecision,
+            outputExponent: buyAsset.precision,
+        }).toFixed();
+        const rate = getInputOutputRate({
+            sellAmountCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const slippage = route.isStreaming ? undefined : slippageTolerancePercentageDecimal;
+        const buyAmountBeforeFeesCryptoBaseUnit = getRouteBuyAmountBeforeFeesCryptoBaseUnit(route.quote);
+        return {
+            id: uuid(),
+            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 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(isFulfilled).map(maybeRoute => maybeRoute.value);
+            if (!routes.length)
+                return Err(makeSwapErrorRight({
+                    message: 'Unable to create any routes',
+                    code: TradeQuoteError.UnsupportedTradePair,
+                    cause: maybeRoutes.filter(isRejected).map(maybeRoute => maybeRoute.reason),
+                }));
+            return Ok(routes);
+        }
+        case 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(isFulfilled).map(maybeRoute => maybeRoute.value);
+            if (!routes.length)
+                return Err(makeSwapErrorRight({
+                    message: 'Unable to create any routes',
+                    code: TradeQuoteError.UnsupportedTradePair,
+                    cause: maybeRoutes.filter(isRejected).map(maybeRoute => maybeRoute.reason),
+                }));
+            return Ok(routes);
+        }
+        case CHAIN_NAMESPACE.CosmosSdk: {
+            const cosmosChainAdapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
+            const { fast } = await cosmosChainAdapter.getFeeData({});
+            return 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 CHAIN_NAMESPACE.Solana: {
+            return Err(makeSwapErrorRight({
+                message: 'Solana is not supported',
+                code: TradeQuoteError.UnsupportedTradePair,
+            }));
+        }
+        case 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 = 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({ 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(isFulfilled).map(maybeRoute => maybeRoute.value);
+            if (!routes.length)
+                return Err(makeSwapErrorRight({
+                    message: 'Unable to create any routes',
+                    code: TradeQuoteError.UnsupportedTradePair,
+                    cause: maybeRoutes.filter(isRejected).map(maybeRoute => maybeRoute.reason),
+                }));
+            return Ok(routes);
+        }
+        case CHAIN_NAMESPACE.Sui: {
+            return Err(makeSwapErrorRight({
+                message: 'SUI is not supported',
+                code: TradeQuoteError.UnsupportedTradePair,
+            }));
+        }
+        case CHAIN_NAMESPACE.Near: {
+            return Err(makeSwapErrorRight({
+                message: 'NEAR is not supported',
+                code: TradeQuoteError.UnsupportedTradePair,
+            }));
+        }
+        case CHAIN_NAMESPACE.Starknet: {
+            return Err(makeSwapErrorRight({
+                message: 'Starknet is not supported',
+                code: TradeQuoteError.UnsupportedTradePair,
+            }));
+        }
+        default:
+            return assertUnreachable(chainNamespace);
+    }
+};

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

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

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

@@ -0,0 +1,76 @@
+import { assertUnreachable } from '@shapeshiftoss/utils';
+import prettyMilliseconds from 'pretty-ms';
+import { ThorchainStatusMessage } from './types.js';
+export 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
+                    ? ThorchainStatusMessage.InboundObserved
+                    : ThorchainStatusMessage.InboundObservingPending;
+            }
+            case 'inbound_confirmation_counted': {
+                const obj = response.stages[key];
+                if (obj === undefined)
+                    continue;
+                return obj.completed
+                    ? ThorchainStatusMessage.InboundConfirmationCounted
+                    : ThorchainStatusMessage.InboundConfirmationPending;
+            }
+            case 'inbound_finalised': {
+                const obj = response.stages[key];
+                if (obj === undefined)
+                    continue;
+                return obj.completed
+                    ? ThorchainStatusMessage.InboundFinalized
+                    : 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 ThorchainStatusMessage.SwapPending;
+                return hasOutboundTx
+                    ? ThorchainStatusMessage.SwapCompleteAwaitingOutbound
+                    : 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
+                        ThorchainStatusMessage.OutboundDelayTimeRemaining.replace('{timeRemaining}', prettyMilliseconds(obj.remaining_delay_seconds * 100))
+                    : ThorchainStatusMessage.OutboundDelayPending;
+            }
+            case 'outbound_signed': {
+                const obj = response.stages[key];
+                if (obj === undefined)
+                    continue;
+                return obj.completed
+                    ? ThorchainStatusMessage.OutboundSigned
+                    : ThorchainStatusMessage.OutboundScheduled;
+            }
+            default:
+                return assertUnreachable(key);
+        }
+    }
+};

package/dist/esm/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/esm/thorchain-utils/getLimitWithManualSlippage/getLimitWithManualSlippage.js

@@ -0,0 +1,7 @@
+import { bn } from '@shapeshiftoss/chain-adapters';
+import { subtractBasisPointAmount } from '@shapeshiftoss/utils';
+import BigNumber from 'bignumber.js';
+export const getLimitWithManualSlippage = ({ expectedAmountOutThorBaseUnit, slippageBps, }) => {
+    const limitWithManualSlippage = subtractBasisPointAmount(bn(expectedAmountOutThorBaseUnit).toFixed(0, BigNumber.ROUND_DOWN), slippageBps, BigNumber.ROUND_DOWN);
+    return limitWithManualSlippage;
+};

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

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

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

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+import { getLimitWithManualSlippage } from './getLimitWithManualSlippage.js';
+describe('getLimitWithManualSlippage', () => {
+    it('should remove slippage from expected amount out', () => {
+        const amountOut = '100';
+        const expectedLimitWithManualSlippage = '50';
+        const slippageBps = 5000; // 50%
+        const limitWithManualSlippage = getLimitWithManualSlippage({
+            expectedAmountOutThorBaseUnit: amountOut,
+            slippageBps,
+        });
+        expect(limitWithManualSlippage).toBe(expectedLimitWithManualSlippage);
+    });
+});

package/dist/esm/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.js';
+import { SwapperName } from '../types.js';
+import type { ThornodePoolResponse } from './types.js';
+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/esm/thorchain-utils/getPoolDetails.js

@@ -0,0 +1,47 @@
+import { bn } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { SwapperName } from '../types.js';
+import { getPoolAssetId, isNativeAsset } from './index.js';
+import { thorService } from './service.js';
+export const getPoolDetails = async (args) => {
+    const { buyAsset, sellAsset, url, swapperName } = args;
+    const res = await thorService.get(url);
+    if (res.isErr())
+        return Err(res.unwrapErr());
+    const { data: poolsResponse } = res.unwrap();
+    const buyPoolId = getPoolAssetId({ assetId: buyAsset.assetId, swapperName });
+    const sellPoolId = 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 === SwapperName.Mayachain)
+            return 3;
+        const sellAssetDepthBps = (() => {
+            // Sell pool is the same as buy pool if selling native fee asset
+            if (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 (isNativeAsset(buyAsset.assetId, swapperName))
+                return sellPool?.derived_depth_bps;
+            return buyPool?.derived_depth_bps;
+        })();
+        if (sellAssetDepthBps && buyAssetDepthBps) {
+            const swapDepthBps = 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 Ok({ buyPoolId, buyPool, sellPoolId, sellPool, streamingInterval });
+};

package/dist/esm/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.js';
+import type { ThornodeQuoteResponseSuccess } from './types.js';
+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 {};

package/dist/esm/thorchain-utils/getQuote.js

@@ -0,0 +1,63 @@
+import { bchAssetId } from '@shapeshiftoss/caip';
+import { bn, fromBaseUnit, toBaseUnit } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import qs from 'qs';
+import { TradeQuoteError } from '../types.js';
+import { createTradeAmountTooSmallErr, makeSwapErrorRight } from '../utils.js';
+import { getThresholdedAffiliateBps } from './getThresholdedAffiliateBps/getThresholdedAffiliateBps.js';
+import { getAffiliate, getDaemonUrl, getNativePrecision, getPoolAssetId } from './index.js';
+import { thorService } from './service.js';
+export const getQuote = async (input, deps) => {
+    const { buyAssetId, receiveAddress, sellAsset, sellAmountCryptoBaseUnit, streaming, streamingInterval, affiliateBps, swapperName, } = input;
+    // don't apply an affiliate fee if it's below the outbound fee for the inbound pool
+    const thresholdedAffiliateBps = await getThresholdedAffiliateBps({
+        sellAsset,
+        sellAmountCryptoBaseUnit,
+        affiliateBps,
+        config: deps.config,
+        swapperName,
+    });
+    const buyPoolId = getPoolAssetId({ assetId: buyAssetId, swapperName });
+    const sellPoolId = getPoolAssetId({ assetId: sellAsset.assetId, swapperName });
+    const sellAmountCryptoPrecision = fromBaseUnit(sellAmountCryptoBaseUnit, sellAsset.precision);
+    // All pool amounts are native precision regardless of token precision
+    const sellAmountCryptoThorBaseUnit = bn(toBaseUnit(sellAmountCryptoPrecision, getNativePrecision(sellAsset.assetId, swapperName)));
+    // The swap endpoint expects BCH receiveAddress's to be stripped of the "bitcoincash:" prefix
+    const parsedReceiveAddress = receiveAddress && buyAssetId === bchAssetId
+        ? receiveAddress.replace('bitcoincash:', '')
+        : receiveAddress;
+    const queryString = qs.stringify({
+        amount: sellAmountCryptoThorBaseUnit.toString(),
+        from_asset: sellPoolId,
+        to_asset: buyPoolId,
+        destination: parsedReceiveAddress,
+        affiliate_bps: thresholdedAffiliateBps,
+        affiliate: getAffiliate(swapperName),
+        ...(streaming && { streaming_interval: streamingInterval }),
+    });
+    const daemonUrl = getDaemonUrl(deps.config, swapperName);
+    const res = await thorService.get(`${daemonUrl}/quote/swap?${queryString}`);
+    if (res.isErr())
+        return Err(res.unwrapErr());
+    const { data } = res.unwrap();
+    const isError = 'error' in data;
+    const notEnoughFeeError = isError && /not enough fee/i.test(data.error);
+    const notEnoughToPayTxFeeError = isError && /not enough to pay transaction fee/i.test(data.error);
+    const tradingIsHaltedError = isError && /trading is halted/.test(data.error);
+    if (notEnoughFeeError || notEnoughToPayTxFeeError)
+        return Err(createTradeAmountTooSmallErr());
+    if (tradingIsHaltedError) {
+        return Err(makeSwapErrorRight({
+            message: `[getQuote]: Trading is halted, cannot process swap`,
+            code: TradeQuoteError.TradingHalted,
+            details: { sellAssetId: sellAsset.assetId, buyAssetId },
+        }));
+    }
+    if (isError) {
+        return Err(makeSwapErrorRight({
+            message: data.error,
+            code: TradeQuoteError.UnknownError,
+        }));
+    }
+    return Ok(data);
+};

package/dist/esm/thorchain-utils/getThresholdedAffiliateBps/getThresholdedAffiliateBps.d.ts

@@ -0,0 +1,11 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { SwapperConfig, SwapperName } from '../../types.js';
+export declare const getOutboundFeeInSellAssetThorBaseUnit: (runePerAsset: string, swapperName: SwapperName) => BigNumber;
+export declare const getExpectedAffiliateFeeSellAssetThorUnit: (sellAmountCryptoBaseUnit: string, sellAsset: Asset, affiliateBps: string, swapperName: SwapperName) => BigNumber;
+export declare const getThresholdedAffiliateBps: ({ sellAsset, affiliateBps, sellAmountCryptoBaseUnit, config, swapperName, }: {
+    sellAsset: Asset;
+    affiliateBps: string;
+    sellAmountCryptoBaseUnit: string;
+    config: SwapperConfig;
+    swapperName: SwapperName;
+}) => Promise<string>;