@shapeshiftoss/swapper 17.7.3 → 18.1.0

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

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThorL1TradeContexts = exports.getSuccessfulTrades = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const uuid_1 = require("uuid");
+const index_1 = require("../../index");
+const types_1 = require("../../types");
+const __1 = require("..");
+const affiliateFee_1 = require("../affiliateFee");
+const getQuote_1 = require("./getQuote");
+const index_2 = require("./index");
+const getSuccessfulTrades = (settled) => {
+    const trades = [];
+    let firstError;
+    for (const result of settled) {
+        if ((0, utils_1.isRejected)(result))
+            continue;
+        if (result.value.isOk())
+            trades.push(result.value.unwrap());
+        else
+            firstError ??= result.value.unwrapErr();
+    }
+    if (trades.length)
+        return (0, monads_1.Ok)(trades);
+    return (0, monads_1.Err)(firstError ??
+        (0, __1.makeSwapErrorRight)({
+            message: 'Unable to create any routes',
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+            cause: settled.filter(utils_1.isRejected).map(result => result.reason),
+        }));
+};
+exports.getSuccessfulTrades = getSuccessfulTrades;
+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 = (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 supportedChainNamespaces = [
+        caip_1.CHAIN_NAMESPACE.Evm,
+        caip_1.CHAIN_NAMESPACE.Utxo,
+        caip_1.CHAIN_NAMESPACE.CosmosSdk,
+        caip_1.CHAIN_NAMESPACE.Solana,
+        caip_1.CHAIN_NAMESPACE.Tron,
+    ];
+    if (!supportedChainNamespaces.includes(chainNamespace)) {
+        return (0, monads_1.Err)((0, __1.makeSwapErrorRight)({
+            message: `${chainNamespace} is not supported`,
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    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 utils_1.BigAmount.fromPrecision({
+            value: utils_1.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 = (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.toFixed(0),
+                requiresBalance: false,
+                asset: buyAsset,
+            };
+        }
+        return protocolFees;
+    };
+    const routes = perRouteValues.map(route => {
+        const buyAmountAfterFeesCryptoBaseUnit = (0, utils_1.convertPrecision)({
+            value: route.expectedAmountOutThorBaseUnit,
+            inputExponent: buyAssetNativePrecision,
+            outputExponent: buyAsset.precision,
+        }).toFixed(0);
+        const rate = (0, __1.getInputOutputRate)({
+            sellAmountCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        return {
+            tradeCommon: {
+                id: (0, uuid_1.v4)(),
+                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: (0, affiliateFee_1.buildAffiliateFee)({
+                    strategy: 'buy_asset',
+                    affiliateBps: route.affiliateBps,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit,
+                    buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                }),
+                swapperMetadata: swapperName === types_1.SwapperName.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 (0, monads_1.Ok)(routes);
+};
+exports.getThorL1TradeContexts = getThorL1TradeContexts;

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

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

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThorL1TradeQuote = void 0;
+const monads_1 = require("@sniptt/monads");
+const utils_1 = require("../../utils");
+const getLimitWithManualSlippage_1 = require("./getLimitWithManualSlippage/getLimitWithManualSlippage");
+const getThorL1TradeContexts_1 = require("./getThorL1TradeContexts");
+const getThorStepData_1 = require("./getThorStepData");
+const index_1 = require("./index");
+const getThorQuoteMemo = (route, swapperName) => {
+    if (!route.quote.memo)
+        return (0, monads_1.Err)((0, utils_1.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 (0, monads_1.Ok)((0, index_1.assertAndProcessMemo)(route.quote.memo, (0, index_1.getAffiliate)(swapperName)));
+    }
+    const limitWithManualSlippage = (0, getLimitWithManualSlippage_1.getLimitWithManualSlippage)({
+        expectedAmountOutThorBaseUnit: route.expectedAmountOutThorBaseUnit,
+        slippageBps: route.slippageBps,
+    });
+    return (0, monads_1.Ok)((0, index_1.addLimitToMemo)({
+        memo: route.quote.memo,
+        limit: limitWithManualSlippage,
+        affilate: (0, index_1.getAffiliate)(swapperName),
+    }));
+};
+const getThorL1TradeQuote = async (input, deps, streamingInterval, tradeType, swapperName) => {
+    const { accountNumber } = input;
+    const addresses = (0, utils_1.assertQuoteAddresses)(input);
+    if (addresses.isErr())
+        return (0, monads_1.Err)(addresses.unwrapErr());
+    const { sendAddress, receiveAddress } = addresses.unwrap();
+    const maybeContexts = await (0, getThorL1TradeContexts_1.getThorL1TradeContexts)(input, deps, streamingInterval, tradeType, swapperName);
+    if (maybeContexts.isErr())
+        return (0, monads_1.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 (0, monads_1.Err)(memoResult.unwrapErr());
+        const memo = memoResult.unwrap();
+        const maybeStepDate = await (0, getThorStepData_1.getThorStepData)({
+            ...stepDataArgs,
+            type: 'quote',
+            input,
+            from: sendAddress,
+            memo,
+        });
+        if (maybeStepDate.isErr())
+            return (0, monads_1.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 (0, monads_1.Ok)(quote);
+    }));
+    return (0, getThorL1TradeContexts_1.getSuccessfulTrades)(maybeQuotes);
+};
+exports.getThorL1TradeQuote = getThorL1TradeQuote;

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

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

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThorL1TradeRate = void 0;
+const monads_1 = require("@sniptt/monads");
+const getThorL1TradeContexts_1 = require("./getThorL1TradeContexts");
+const getThorStepData_1 = require("./getThorStepData");
+const getThorL1TradeRate = async (input, deps, streamingInterval, tradeType, swapperName) => {
+    const { accountNumber, receiveAddress } = input;
+    const maybeContexts = await (0, getThorL1TradeContexts_1.getThorL1TradeContexts)(input, deps, streamingInterval, tradeType, swapperName);
+    if (maybeContexts.isErr())
+        return (0, monads_1.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 (0, getThorStepData_1.getThorStepData)({
+            ...stepDataArgs,
+            type: 'rate',
+            input,
+            memo: '',
+        });
+        if (maybeStepData.isErr())
+            return (0, monads_1.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 (0, monads_1.Ok)(rate);
+    }));
+    return (0, getThorL1TradeContexts_1.getSuccessfulTrades)(maybeRates);
+};
+exports.getThorL1TradeRate = getThorL1TradeRate;

package/dist/cjs/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';
+import type { SolanaComputeBudgetOptions } from '../solana';
+import { TradeType } from './types';
+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 {};