@shapeshiftoss/swapper 17.6.6-alpha.1 → 17.6.6

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

@@ -1,278 +0,0 @@
-import { CHAIN_NAMESPACE, fromAssetId } from '@shapeshiftoss/caip';
-import * as adapters from '@shapeshiftoss/chain-adapters';
-import { assertUnreachable, bn, bnOrZero, convertDecimalPercentageToBasisPoints, convertPrecision, fromBaseUnit, isFulfilled, isRejected, toBaseUnit, } from '@shapeshiftoss/utils';
-import { Err, Ok } from '@sniptt/monads';
-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 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,
-            }));
-        }
-        default:
-            return assertUnreachable(chainNamespace);
-    }
-};

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

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

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

@@ -1,76 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

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

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

@@ -1,14 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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>;

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

@@ -1,34 +0,0 @@
-import { bn, convertBasisPointsToDecimalPercentage, convertPrecision } from '@shapeshiftoss/utils';
-import { getMidgardUrl, getNativeFee, getNativePrecision, getPoolAssetId, isNativeAsset, thorService, } from '../index.js';
-export const getOutboundFeeInSellAssetThorBaseUnit = (runePerAsset, swapperName) => {
-    return bn(getNativeFee(swapperName)).dividedBy(runePerAsset);
-};
-export const getExpectedAffiliateFeeSellAssetThorUnit = (sellAmountCryptoBaseUnit, sellAsset, affiliateBps, swapperName) => {
-    const sellAmountThorUnit = convertPrecision({
-        value: sellAmountCryptoBaseUnit,
-        inputExponent: sellAsset.precision,
-        outputExponent: getNativePrecision(sellAsset.assetId, swapperName),
-    });
-    const affiliatePercent = convertBasisPointsToDecimalPercentage(affiliateBps);
-    return sellAmountThorUnit.times(affiliatePercent);
-};
-// don't apply an affiliate fee if it's below the outbound fee for the inbound pool
-export const getThresholdedAffiliateBps = async ({ sellAsset, affiliateBps, sellAmountCryptoBaseUnit, config, swapperName, }) => {
-    const midgardUrl = getMidgardUrl(config, swapperName);
-    const outboundFeeSellAssetThorUnit = await (async () => {
-        if (isNativeAsset(sellAsset.assetId, swapperName))
-            return getNativeFee(swapperName);
-        const sellPoolId = getPoolAssetId({ assetId: sellAsset.assetId, swapperName });
-        // get pool data for the sell asset
-        const res = await thorService.get(`${midgardUrl}/pool/${sellPoolId}`);
-        if (res.isErr())
-            throw res.unwrapErr();
-        const pool = res.unwrap().data;
-        // calculate the rune outbound fee denominated in the sell asset, in native units
-        return getOutboundFeeInSellAssetThorBaseUnit(pool.assetPrice, swapperName);
-    })();
-    // calculate the expected affiliate fee, in native units
-    const expectedAffiliateFeeSellAssetThorUnit = getExpectedAffiliateFeeSellAssetThorUnit(sellAmountCryptoBaseUnit, sellAsset, affiliateBps, swapperName);
-    const isAffiliateFeeBelowOutboundFee = expectedAffiliateFeeSellAssetThorUnit.lte(outboundFeeSellAssetThorUnit);
-    return isAffiliateFeeBelowOutboundFee ? '0' : affiliateBps;
-};

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

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