@shapeshiftoss/swapper 17.8.0 → 18.1.0

package/dist/cjs/{thorchain-utils → utils/thorchain}/checkTradeStatus.js

@@ -6,13 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkTradeStatus = void 0;
 const caip_1 = require("@shapeshiftoss/caip");
 const unchained_client_1 = require("@shapeshiftoss/unchained-client");
+const utils_1 = require("@shapeshiftoss/utils");
 const axios_1 = __importDefault(require("axios"));
-const utils_1 = require("../utils");
+const utils_2 = require("../../utils");
 const getLatestThorTxStatusMessage_1 = require("./getLatestThorTxStatusMessage");
 const parseBuyTxHash_1 = require("./parseBuyTxHash");
 const checkTradeStatus = async ({ txHash, chainId, address, fetchIsSmartContractAddressQuery, assertGetEvmChainAdapter, nodeUrl, apiUrl, nativeChain, }) => {
     try {
-        const maybeSafeTransactionStatus = await (0, utils_1.checkSafeTransactionStatus)({
+        const maybeSafeTransactionStatus = await (0, utils_2.checkSafeTransactionStatus)({
             txHash,
             chainId,
             assertGetEvmChainAdapter,
@@ -27,6 +28,9 @@ const checkTradeStatus = async ({ txHash, chainId, address, fetchIsSmartContract
             // Mutate txHash and continue with regular status check flow.
             txHash = maybeSafeTransactionStatus.buyTxHash;
         }
+        const swapperTxId = txHash.replace(/^0x/, '');
+        const nativeExplorerTxLink = nativeChain === 'THOR' ? utils_1.thorchain.explorerTxLink : utils_1.mayachain.explorerTxLink;
+        const swapperTxLink = `${nativeExplorerTxLink}${swapperTxId}`;
         // check for native chain tx errors
         if ((chainId === caip_1.thorchainChainId && nativeChain === 'THOR') ||
             (chainId === caip_1.mayachainChainId && nativeChain === 'MAYA')) {
@@ -35,6 +39,8 @@ const checkTradeStatus = async ({ txHash, chainId, address, fetchIsSmartContract
                 return {
                     status: unchained_client_1.TxStatus.Failed,
                     buyTxHash: undefined,
+                    swapperTxId,
+                    swapperTxLink,
                     message: tx.events[0].error.message,
                 };
             }
@@ -46,7 +52,13 @@ const checkTradeStatus = async ({ txHash, chainId, address, fetchIsSmartContract
         ]);
         // We care about txStatusData errors because it drives all of the status logic.
         if ('error' in txStatusData) {
-            return { buyTxHash: undefined, status: unchained_client_1.TxStatus.Unknown, message: undefined };
+            return {
+                buyTxHash: undefined,
+                status: unchained_client_1.TxStatus.Unknown,
+                swapperTxId,
+                swapperTxLink,
+                message: undefined,
+            };
         }
         // We use planned_out_txs to determine the number of out txs because we don't want to derive
         // swap completion based on the length of out_txs which is populated as the trade executed
@@ -56,16 +68,22 @@ const checkTradeStatus = async ({ txHash, chainId, address, fetchIsSmartContract
         const hasOutboundL1Tx = lastOutTx !== undefined && lastOutTx.chain !== nativeChain;
         const hasOutboundNativeTx = lastOutTx !== undefined && lastOutTx.chain === nativeChain;
         if (txStatusData.planned_out_txs?.some(plannedOutTx => plannedOutTx.refund)) {
-            return { buyTxHash, status: unchained_client_1.TxStatus.Failed, message: undefined };
+            return { buyTxHash, status: unchained_client_1.TxStatus.Failed, swapperTxId, swapperTxLink, message: undefined };
         }
         // We consider the transaction confirmed as soon as we have a buyTxHash
         // For UTXOs, this means that the swap will be confirmed as soon as Txs hit the mempool
         // Which is actually correct, as we update UTXO balances optimistically
         if (!('error' in txData) && buyTxHash && (hasOutboundL1Tx || hasOutboundNativeTx)) {
-            return { buyTxHash, status: unchained_client_1.TxStatus.Confirmed, message: undefined };
+            return {
+                buyTxHash,
+                status: unchained_client_1.TxStatus.Confirmed,
+                swapperTxId,
+                swapperTxLink,
+                message: undefined,
+            };
         }
         const message = (0, getLatestThorTxStatusMessage_1.getLatestThorTxStatusMessage)(txStatusData, hasOutboundL1Tx);
-        return { buyTxHash, status: unchained_client_1.TxStatus.Pending, message };
+        return { buyTxHash, status: unchained_client_1.TxStatus.Pending, swapperTxId, swapperTxLink, message };
     }
     catch (e) {
         const message = (() => {

package/dist/cjs/{thorchain-utils → utils/thorchain}/getInboundAddressDataForChain.d.ts

@@ -1,5 +1,5 @@
 import type { AssetId } from '@shapeshiftoss/caip';
 import type { Result } from '@sniptt/monads';
-import type { SwapErrorRight, SwapperName } from '../types';
+import type { SwapErrorRight, SwapperName } from '../../types';
 import type { InboundAddressResponse } from './types';
 export declare const getInboundAddressDataForChain: (daemonUrl: string, assetId: AssetId | undefined, excludeHalted: boolean, swapperName: SwapperName) => Promise<Result<InboundAddressResponse, SwapErrorRight>>;

package/dist/cjs/{thorchain-utils → utils/thorchain}/getInboundAddressDataForChain.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getInboundAddressDataForChain = void 0;
 const monads_1 = require("@sniptt/monads");
-const types_1 = require("../types");
-const utils_1 = require("../utils");
+const types_1 = require("../../types");
+const utils_1 = require("../../utils");
 const index_1 = require("./index");
 const service_1 = require("./service");
 const getInboundAddressDataForChain = async (daemonUrl, assetId, excludeHalted, swapperName) => {

package/dist/cjs/{thorchain-utils → utils/thorchain}/getPoolDetails.d.ts

@@ -1,7 +1,7 @@
 import type { Asset } from '@shapeshiftoss/types';
 import type { Result } from '@sniptt/monads';
-import type { SwapErrorRight } from '../types';
-import { SwapperName } from '../types';
+import type { SwapErrorRight } from '../../types';
+import { SwapperName } from '../../types';
 import type { ThornodePoolResponse } from './types';
 type GetPoolDetailsArgs = {
     buyAsset: Asset;

package/dist/cjs/{thorchain-utils → utils/thorchain}/getPoolDetails.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPoolDetails = void 0;
 const utils_1 = require("@shapeshiftoss/utils");
 const monads_1 = require("@sniptt/monads");
-const types_1 = require("../types");
+const types_1 = require("../../types");
 const index_1 = require("./index");
 const service_1 = require("./service");
 const getPoolDetails = async (args) => {

package/dist/cjs/{thorchain-utils → utils/thorchain}/getQuote.d.ts

@@ -1,7 +1,7 @@
 import type { AssetId } from '@shapeshiftoss/caip';
 import type { Asset } from '@shapeshiftoss/types';
 import type { Result } from '@sniptt/monads';
-import type { SwapErrorRight, SwapperDeps, SwapperName } from '../types';
+import type { SwapErrorRight, SwapperDeps, SwapperName } from '../../types';
 import type { ThornodeQuoteResponseSuccess } from './types';
 type GetQuoteArgs = {
     sellAsset: Asset;

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

@@ -8,8 +8,8 @@ const caip_1 = require("@shapeshiftoss/caip");
 const utils_1 = require("@shapeshiftoss/utils");
 const monads_1 = require("@sniptt/monads");
 const qs_1 = __importDefault(require("qs"));
-const types_1 = require("../types");
-const utils_2 = require("../utils");
+const types_1 = require("../../types");
+const utils_2 = require("../../utils");
 const index_1 = require("./index");
 const service_1 = require("./service");
 const getQuote = async (input, deps) => {

package/dist/cjs/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';
+import type { GetThorStepDataArgs } from './getThorStepData';
+import type { ThorTradeQuoteInput, ThorTradeRateInput, ThorTradeRoute, TradeType } from './types';
+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/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 {};