@shapeshiftoss/swapper 17.8.0 → 18.1.0

package/dist/esm/{thorchain-utils → utils/thorchain}/getQuote.js

@@ -2,8 +2,8 @@ import { bchAssetId } from '@shapeshiftoss/caip';
 import { BigAmount, bn } 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 { TradeQuoteError } from '../../types.js';
+import { createTradeAmountTooSmallErr, makeSwapErrorRight } from '../../utils/index.js';
 import { getAffiliate, getDaemonUrl, getNativePrecision, getPoolAssetId } from './index.js';
 import { thorService } from './service.js';
 export const getQuote = async (input, deps) => {

package/dist/esm/utils/thorchain/getThorL1TradeContexts.d.ts

@@ -0,0 +1,18 @@
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, SwapperName, TradeCommon, TradeStepCommon } from '../../types.js';
+import type { GetThorStepDataArgs } from './getThorStepData.js';
+import type { ThorTradeQuoteInput, ThorTradeRateInput, ThorTradeRoute, TradeType } from './types.js';
+export declare const getSuccessfulTrades: <T>(settled: PromiseSettledResult<Result<T, SwapErrorRight>>[]) => Result<T[], SwapErrorRight>;
+export type ThorL1TradeContext = {
+    route: ThorTradeRoute;
+    tradeCommon: TradeCommon & {
+        isStreaming: boolean;
+        tradeType: TradeType;
+        expiry: number;
+        recommendedMinimumCryptoBaseUnit: string;
+    };
+    stepCommon: Omit<TradeStepCommon, 'feeData' | 'allowanceContract'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    stepDataArgs: Omit<GetThorStepDataArgs, 'type' | 'input' | 'from' | 'memo'>;
+};
+export declare const getThorL1TradeContexts: (input: ThorTradeQuoteInput | ThorTradeRateInput, deps: SwapperDeps, streamingInterval: number, tradeType: TradeType, swapperName: SwapperName) => Promise<Result<ThorL1TradeContext[], SwapErrorRight>>;

package/dist/esm/utils/thorchain/getThorL1TradeContexts.js

@@ -0,0 +1,195 @@
+import { CHAIN_NAMESPACE, fromAssetId } from '@shapeshiftoss/caip';
+import { BigAmount, bn, bnOrZero, convertDecimalPercentageToBasisPoints, convertPrecision, isRejected, } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../index.js';
+import { SwapperName as SwapperNameEnum, TradeQuoteError } from '../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../index.js';
+import { buildAffiliateFee } from '../affiliateFee.js';
+import { getQuote } from './getQuote.js';
+import { getNativePrecision, getSwapSource } from './index.js';
+export const getSuccessfulTrades = (settled) => {
+    const trades = [];
+    let firstError;
+    for (const result of settled) {
+        if (isRejected(result))
+            continue;
+        if (result.value.isOk())
+            trades.push(result.value.unwrap());
+        else
+            firstError ??= result.value.unwrapErr();
+    }
+    if (trades.length)
+        return Ok(trades);
+    return Err(firstError ??
+        makeSwapErrorRight({
+            message: 'Unable to create any routes',
+            code: TradeQuoteError.UnsupportedTradePair,
+            cause: settled.filter(isRejected).map(result => result.reason),
+        }));
+};
+export const getThorL1TradeContexts = async (input, deps, streamingInterval, tradeType, swapperName) => {
+    const { sellAsset, buyAsset, receiveAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmountCryptoBaseUnit, affiliateBps: requestedAffiliateBps, } = input;
+    // "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 supportedChainNamespaces = [
+        CHAIN_NAMESPACE.Evm,
+        CHAIN_NAMESPACE.Utxo,
+        CHAIN_NAMESPACE.CosmosSdk,
+        CHAIN_NAMESPACE.Solana,
+        CHAIN_NAMESPACE.Tron,
+    ];
+    if (!supportedChainNamespaces.includes(chainNamespace)) {
+        return Err(makeSwapErrorRight({
+            message: `${chainNamespace} is not supported`,
+            code: TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    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 BigAmount.fromPrecision({
+            value: BigAmount.fromBaseUnit({
+                value: buyAmountBeforeFeesCryptoThorPrecision,
+                precision: buyAssetNativePrecision,
+            }).toPrecision(),
+            precision: buyAsset.precision,
+        }).toBaseUnit();
+    };
+    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.toFixed(0),
+                requiresBalance: false,
+                asset: buyAsset,
+            };
+        }
+        return protocolFees;
+    };
+    const routes = perRouteValues.map(route => {
+        const buyAmountAfterFeesCryptoBaseUnit = convertPrecision({
+            value: route.expectedAmountOutThorBaseUnit,
+            inputExponent: buyAssetNativePrecision,
+            outputExponent: buyAsset.precision,
+        }).toFixed(0);
+        const rate = getInputOutputRate({
+            sellAmountCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        return {
+            tradeCommon: {
+                id: uuid(),
+                rate,
+                affiliateBps: route.affiliateBps,
+                isStreaming: route.isStreaming,
+                slippageTolerancePercentageDecimal: route.isStreaming
+                    ? undefined
+                    : slippageTolerancePercentageDecimal,
+                swapperName,
+                tradeType,
+                expiry: route.quote.expiry,
+                recommendedMinimumCryptoBaseUnit,
+            },
+            stepCommon: {
+                estimatedExecutionTimeMs: route.estimatedExecutionTimeMs,
+                rate,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmountCryptoBaseUnit,
+                buyAmountBeforeFeesCryptoBaseUnit: getRouteBuyAmountBeforeFeesCryptoBaseUnit(route.quote),
+                buyAmountAfterFeesCryptoBaseUnit,
+                source: route.source,
+                buyAsset,
+                sellAsset,
+                affiliateFee: buildAffiliateFee({
+                    strategy: 'buy_asset',
+                    affiliateBps: route.affiliateBps,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit,
+                    buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                }),
+                swapperMetadata: swapperName === SwapperNameEnum.Mayachain
+                    ? { name: 'mayachain', maxStreamingQuantity: route.quote.max_streaming_quantity }
+                    : { name: 'thorchain', maxStreamingQuantity: route.quote.max_streaming_quantity },
+            },
+            route,
+            protocolFees: getProtocolFees(route.quote),
+            stepDataArgs: {
+                deps,
+                sellAsset,
+                swapperName,
+                tradeType,
+                sellAmountCryptoBaseUnit,
+                expiry: route.quote.expiry,
+                rawMemo: route.quote.memo,
+            },
+        };
+    });
+    return Ok(routes);
+};

package/dist/esm/utils/thorchain/getThorL1TradeQuote.d.ts

@@ -0,0 +1,4 @@
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight, SwapperDeps, SwapperName } from '../../types.js';
+import type { ThorTradeQuote, ThorTradeQuoteInput, TradeType } from './types.js';
+export declare const getThorL1TradeQuote: (input: ThorTradeQuoteInput, deps: SwapperDeps, streamingInterval: number, tradeType: TradeType, swapperName: SwapperName) => Promise<Result<ThorTradeQuote[], SwapErrorRight>>;

package/dist/esm/utils/thorchain/getThorL1TradeQuote.js

@@ -0,0 +1,69 @@
+import { Err, Ok } from '@sniptt/monads';
+import { assertQuoteAddresses, makeTradeStepBuildFailedErr } from '../../utils/index.js';
+import { getLimitWithManualSlippage } from './getLimitWithManualSlippage/getLimitWithManualSlippage.js';
+import { getSuccessfulTrades, getThorL1TradeContexts } from './getThorL1TradeContexts.js';
+import { getThorStepData } from './getThorStepData.js';
+import { addLimitToMemo, assertAndProcessMemo, getAffiliate } from './index.js';
+const getThorQuoteMemo = (route, swapperName) => {
+    if (!route.quote.memo)
+        return Err(makeTradeStepBuildFailedErr('getThorL1TradeQuote'));
+    // 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 Ok(assertAndProcessMemo(route.quote.memo, getAffiliate(swapperName)));
+    }
+    const limitWithManualSlippage = getLimitWithManualSlippage({
+        expectedAmountOutThorBaseUnit: route.expectedAmountOutThorBaseUnit,
+        slippageBps: route.slippageBps,
+    });
+    return Ok(addLimitToMemo({
+        memo: route.quote.memo,
+        limit: limitWithManualSlippage,
+        affilate: getAffiliate(swapperName),
+    }));
+};
+export const getThorL1TradeQuote = async (input, deps, streamingInterval, tradeType, swapperName) => {
+    const { accountNumber } = input;
+    const addresses = assertQuoteAddresses(input);
+    if (addresses.isErr())
+        return Err(addresses.unwrapErr());
+    const { sendAddress, receiveAddress } = addresses.unwrap();
+    const maybeContexts = await getThorL1TradeContexts(input, deps, streamingInterval, tradeType, swapperName);
+    if (maybeContexts.isErr())
+        return Err(maybeContexts.unwrapErr());
+    const routes = maybeContexts.unwrap();
+    const maybeQuotes = await Promise.allSettled(routes.map(async ({ route, tradeCommon, stepCommon, protocolFees, stepDataArgs, }) => {
+        const memoResult = getThorQuoteMemo(route, swapperName);
+        if (memoResult.isErr())
+            return Err(memoResult.unwrapErr());
+        const memo = memoResult.unwrap();
+        const maybeStepDate = await getThorStepData({
+            ...stepDataArgs,
+            type: 'quote',
+            input,
+            from: sendAddress,
+            memo,
+        });
+        if (maybeStepDate.isErr())
+            return Err(maybeStepDate.unwrapErr());
+        const { networkFeeCryptoBaseUnit, transactionData, data, router } = maybeStepDate.unwrap();
+        const quote = {
+            ...tradeCommon,
+            quoteOrRate: 'quote',
+            memo,
+            receiveAddress,
+            data,
+            steps: [
+                {
+                    ...stepCommon,
+                    accountNumber,
+                    allowanceContract: router ?? '',
+                    transactionData,
+                    feeData: { networkFeeCryptoBaseUnit, protocolFees },
+                },
+            ],
+        };
+        return Ok(quote);
+    }));
+    return getSuccessfulTrades(maybeQuotes);
+};

package/dist/esm/utils/thorchain/getThorL1TradeRate.d.ts

@@ -0,0 +1,4 @@
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight, SwapperDeps, SwapperName } from '../../types.js';
+import type { ThorTradeRate, ThorTradeRateInput, TradeType } from './types.js';
+export declare const getThorL1TradeRate: (input: ThorTradeRateInput, deps: SwapperDeps, streamingInterval: number, tradeType: TradeType, swapperName: SwapperName) => Promise<Result<ThorTradeRate[], SwapErrorRight>>;

package/dist/esm/utils/thorchain/getThorL1TradeRate.js

@@ -0,0 +1,39 @@
+import { Err, Ok } from '@sniptt/monads';
+import { getSuccessfulTrades, getThorL1TradeContexts } from './getThorL1TradeContexts.js';
+import { getThorStepData } from './getThorStepData.js';
+export const getThorL1TradeRate = async (input, deps, streamingInterval, tradeType, swapperName) => {
+    const { accountNumber, receiveAddress } = input;
+    const maybeContexts = await getThorL1TradeContexts(input, deps, streamingInterval, tradeType, swapperName);
+    if (maybeContexts.isErr())
+        return Err(maybeContexts.unwrapErr());
+    const routes = maybeContexts.unwrap();
+    const maybeRates = await Promise.allSettled(routes.map(async ({ tradeCommon, stepCommon, protocolFees, stepDataArgs, }) => {
+        // Rates carry no processed memo; step data sizes utxo/solana estimation with the raw thornode memo
+        const maybeStepData = await getThorStepData({
+            ...stepDataArgs,
+            type: 'rate',
+            input,
+            memo: '',
+        });
+        if (maybeStepData.isErr())
+            return Err(maybeStepData.unwrapErr());
+        const { networkFeeCryptoBaseUnit, data, router } = maybeStepData.unwrap();
+        const rate = {
+            ...tradeCommon,
+            quoteOrRate: 'rate',
+            memo: '',
+            receiveAddress,
+            data,
+            steps: [
+                {
+                    ...stepCommon,
+                    accountNumber,
+                    allowanceContract: router ?? '',
+                    feeData: { networkFeeCryptoBaseUnit, protocolFees },
+                },
+            ],
+        };
+        return Ok(rate);
+    }));
+    return getSuccessfulTrades(maybeRates);
+};

package/dist/esm/utils/thorchain/getThorStepData.d.ts

@@ -0,0 +1,35 @@
+import type { Result } from '@sniptt/monads';
+import type { Address } from 'viem';
+import type { StepDataArgs, SwapErrorRight, SwapperName, TxBuildData } from '../../types.js';
+import type { SolanaComputeBudgetOptions } from '../solana/index.js';
+import { TradeType } from './types.js';
+export declare const THOR_SOLANA_COMPUTE_BUDGET: SolanaComputeBudgetOptions;
+type BaseArgs = {
+    swapperName: SwapperName;
+    tradeType: TradeType;
+    sellAmountCryptoBaseUnit: string;
+    memo: string;
+    expiry: number;
+    rawMemo: string | undefined;
+    longtail?: {
+        aggregator: Address;
+        amountOutMin: bigint;
+        deadline: bigint;
+    };
+};
+export type GetThorStepDataArgs = StepDataArgs<BaseArgs>;
+type ThorRateStepData = {
+    router?: Address;
+    data?: string;
+    networkFeeCryptoBaseUnit: string | undefined;
+};
+type ThorQuoteStepData = ThorRateStepData & {
+    transactionData?: TxBuildData;
+};
+export declare function getThorStepData(args: Extract<GetThorStepDataArgs, {
+    type: 'rate';
+}>): Promise<Result<ThorRateStepData, SwapErrorRight>>;
+export declare function getThorStepData(args: Extract<GetThorStepDataArgs, {
+    type: 'quote';
+}>): Promise<Result<ThorQuoteStepData, SwapErrorRight>>;
+export {};