@shapeshiftoss/swapper 17.8.0 → 18.1.0

package/dist/esm/swappers/ThorchainSwapper/utils/getL1ToLongtailQuote.js

@@ -1,86 +1,50 @@
-import { ethChainId } from '@shapeshiftoss/caip';
 import { TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET } from '@shapeshiftoss/contracts';
-import { convertDecimalPercentageToBasisPoints, isFulfilled, isRejected, isResolvedErr, } from '@shapeshiftoss/utils';
+import { convertDecimalPercentageToBasisPoints } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
-import { getAffiliate, getL1RateOrQuote, TradeType } from '../../../thorchain-utils/index.js';
 import { TradeQuoteError } from '../../../types.js';
-import { getHopByIndex, makeSwapErrorRight } from '../../../utils.js';
+import { assertQuoteAddresses, makeSwapErrorRight } from '../../../utils/index.js';
+import { getAffiliate, getSuccessfulTrades, getThorL1TradeQuote, getThorStepData, TradeType, } from '../../../utils/thorchain/index.js';
 import { addL1ToLongtailPartsToMemo } from './addL1ToLongtailPartsToMemo/addL1ToLongtailPartsToMemo.js';
+import { assertValidL1ToLongtailTrade } from './assertValidLongtailTrade.js';
 import { getBestAggregator } from './getBestAggregator.js';
 import { getTokenFromAsset, getWrappedToken } from './longTailHelpers.js';
 // This just uses UniswapV3 to get the longtail quote for now.
 export const getL1ToLongtailQuote = async (input, deps, streamingInterval, swapperName) => {
     const { buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmountCryptoBaseUnit, sellAsset, slippageTolerancePercentageDecimal, } = input;
-    const longtailTokensJson = await import('../generated/generatedThorLongtailTokens.json');
-    const longtailTokens = longtailTokensJson.default;
-    if (!longtailTokens.includes(buyAsset.assetId)) {
-        return Err(makeSwapErrorRight({
-            message: `[getThorTradeQuote] - Unsupported buyAssetId ${buyAsset.assetId}.`,
-            code: TradeQuoteError.UnsupportedTradePair,
-            details: { buyAsset, sellAsset },
-        }));
-    }
-    /*
-      We only support L1 -> ethereum longtail swaps for now.
-    */
-    if (buyAsset.chainId !== ethChainId) {
-        return Err(makeSwapErrorRight({
-            message: `[getThorTradeQuote] - Unsupported chainId ${buyAsset.chainId}.`,
-            code: TradeQuoteError.UnsupportedChain,
-            details: { buyAssetChainId: buyAsset.chainId },
-        }));
-    }
-    const sellAssetChainId = sellAsset.chainId;
-    const buyAssetChainId = buyAsset.chainId;
-    const sellAssetFeeAssetId = deps.assertGetChainAdapter(sellAssetChainId).getFeeAssetId();
-    const sellAssetFeeAsset = sellAssetFeeAssetId ? deps.assetsById[sellAssetFeeAssetId] : undefined;
-    const buyAssetFeeAssetId = deps.assertGetChainAdapter(buyAssetChainId).getFeeAssetId();
-    const buyAssetFeeAsset = buyAssetFeeAssetId ? deps.assetsById[buyAssetFeeAssetId] : undefined;
-    if (!buyAssetFeeAsset) {
-        return Err(makeSwapErrorRight({
-            message: `[getThorTradeQuote] - No native buy asset found for ${buyAssetChainId}.`,
-            code: TradeQuoteError.InternalError,
-            details: { buyAssetChainId },
-        }));
-    }
-    if (!sellAssetFeeAsset) {
-        return Err(makeSwapErrorRight({
-            message: `[getThorTradeQuote] - No native buy asset found for ${sellAssetChainId}.`,
-            code: TradeQuoteError.InternalError,
-            details: { sellAssetChainId },
-        }));
-    }
+    const addresses = assertQuoteAddresses(input);
+    if (addresses.isErr())
+        return Err(addresses.unwrapErr());
+    const { sendAddress: from } = addresses.unwrap();
+    const assertion = await assertValidL1ToLongtailTrade({ sellAsset, buyAsset, deps });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const { buyAssetFeeAsset, longtailTokens } = assertion.unwrap();
     const l1Tol1QuoteInput = {
         ...input,
         buyAsset: buyAssetFeeAsset,
         sellAsset,
         sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmountCryptoBaseUnit,
     };
-    const maybeThorchainQuotes = await getL1RateOrQuote(l1Tol1QuoteInput, deps, streamingInterval, TradeType.L1ToLongTail, swapperName);
-    if (maybeThorchainQuotes.isErr())
-        return Err(maybeThorchainQuotes.unwrapErr());
-    const thorchainQuotes = maybeThorchainQuotes.unwrap();
-    let bestAggregator;
-    let quotedAmountOut;
-    const promises = await Promise.allSettled(thorchainQuotes.map(async (quote) => {
-        // A quote always has a first step
-        const onlyStep = getHopByIndex(quote, 0);
-        // Or well... it should.
-        if (!onlyStep) {
+    const maybeL1Quotes = await getThorL1TradeQuote(l1Tol1QuoteInput, deps, streamingInterval, TradeType.L1ToLongTail, swapperName);
+    if (maybeL1Quotes.isErr())
+        return Err(maybeL1Quotes.unwrapErr());
+    const maybeQuotes = await Promise.allSettled(maybeL1Quotes.unwrap().map(async (quote) => {
+        const [step] = quote.steps;
+        const maybeBestAggregator = await getBestAggregator(buyAssetFeeAsset, getWrappedToken(buyAssetFeeAsset), getTokenFromAsset(buyAsset), step.buyAmountAfterFeesCryptoBaseUnit);
+        if (maybeBestAggregator.isErr())
+            return Err(maybeBestAggregator.unwrapErr());
+        const { bestAggregator, quotedAmountOut } = maybeBestAggregator.unwrap();
+        // Paranoia - a zero expected amount out would likely lead to a loss of funds, and is encoded into
+        // the memo below as well as the calldata
+        if (quotedAmountOut <= 0n) {
             return Err(makeSwapErrorRight({
-                message: `[getL1ToLongtailQuote] - First hop not found`,
+                message: '[getL1ToLongtailQuote] - expected a positive amount out',
                 code: TradeQuoteError.InternalError,
             }));
         }
-        const maybeBestAggregator = await getBestAggregator(buyAssetFeeAsset, getWrappedToken(buyAssetFeeAsset), getTokenFromAsset(buyAsset), onlyStep.buyAmountAfterFeesCryptoBaseUnit);
-        if (maybeBestAggregator.isErr())
-            return Err(maybeBestAggregator.unwrapErr());
-        const unwrappedResult = maybeBestAggregator.unwrap();
-        bestAggregator = unwrappedResult.bestAggregator;
-        quotedAmountOut = unwrappedResult.quotedAmountOut;
         const updatedMemo = addL1ToLongtailPartsToMemo({
-            sellAssetChainId,
+            sellAssetChainId: sellAsset.chainId,
             aggregator: bestAggregator,
             finalAssetAssetId: buyAsset.assetId,
             finalAssetAmountOut: quotedAmountOut.toString(),
@@ -90,10 +54,28 @@ export const getL1ToLongtailQuote = async (input, deps, streamingInterval, swapp
             longtailTokens,
             affiliate: getAffiliate(swapperName),
         });
+        // getThorL1TradeQuote built the step against the pre-aggregator memo, so rebuild the tx data
+        // and fees through the shared step data now that the final memo is known
+        const stepData = await getThorStepData({
+            type: 'quote',
+            input,
+            from,
+            deps,
+            swapperName,
+            tradeType: TradeType.L1ToLongTail,
+            sellAsset,
+            sellAmountCryptoBaseUnit: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            memo: updatedMemo,
+            expiry: quote.expiry,
+            rawMemo: updatedMemo,
+        });
+        if (stepData.isErr())
+            return Err(stepData.unwrapErr());
+        const { data, transactionData, networkFeeCryptoBaseUnit } = stepData.unwrap();
         return Ok({
             ...quote,
             memo: updatedMemo,
-            aggregator: bestAggregator,
+            data,
             steps: quote.steps.map(s => ({
                 ...s,
                 buyAsset,
@@ -101,19 +83,11 @@ export const getL1ToLongtailQuote = async (input, deps, streamingInterval, swapp
                 // This is wrong, we should get the get the value before fees or display ETH value received after the thorchain bridge
                 buyAmountBeforeFeesCryptoBaseUnit: quotedAmountOut.toString(),
                 allowanceContract: TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET,
+                transactionData,
+                feeData: { ...s.feeData, networkFeeCryptoBaseUnit },
             })),
             isLongtail: true,
-            longtailData: {
-                L1ToLongtailExpectedAmountOut: quotedAmountOut.toString(),
-            },
         });
     }));
-    if (promises.every(promise => isRejected(promise) || isResolvedErr(promise))) {
-        return Err(makeSwapErrorRight({
-            message: '[getThorTradeQuote] - failed to get best aggregator',
-            code: TradeQuoteError.InternalError,
-        }));
-    }
-    const updatedQuotes = promises.filter(isFulfilled).map(element => element.value.unwrap());
-    return Ok(updatedQuotes);
+    return getSuccessfulTrades(maybeQuotes);
 };

package/dist/esm/swappers/ThorchainSwapper/utils/getL1ToLongtailRate.d.ts

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

package/dist/esm/swappers/ThorchainSwapper/utils/getL1ToLongtailRate.js

@@ -1,87 +1,34 @@
-import { ethChainId } from '@shapeshiftoss/caip';
 import { TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET } from '@shapeshiftoss/contracts';
-import { isFulfilled, isRejected, isResolvedErr } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
-import { getL1RateOrQuote, TradeType } from '../../../thorchain-utils/index.js';
-import { TradeQuoteError } from '../../../types.js';
-import { getHopByIndex, makeSwapErrorRight } from '../../../utils.js';
+import { getSuccessfulTrades, getThorL1TradeRate, TradeType } from '../../../utils/thorchain/index.js';
+import { assertValidL1ToLongtailTrade } from './assertValidLongtailTrade.js';
 import { getBestAggregator } from './getBestAggregator.js';
 import { getTokenFromAsset, getWrappedToken } from './longTailHelpers.js';
 export const getL1ToLongtailRate = async (input, deps, streamingInterval, swapperName) => {
     const { buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmountCryptoBaseUnit, sellAsset, } = input;
-    const longtailTokensJson = await import('../generated/generatedThorLongtailTokens.json');
-    const longtailTokens = longtailTokensJson.default;
-    if (!longtailTokens.includes(buyAsset.assetId)) {
-        return Err(makeSwapErrorRight({
-            message: `[getThorTradeQuote] - Unsupported buyAssetId ${buyAsset.assetId}.`,
-            code: TradeQuoteError.UnsupportedTradePair,
-            details: { buyAsset, sellAsset },
-        }));
-    }
-    /*
-      We only support L1 -> ethereum longtail swaps for now.
-    */
-    if (buyAsset.chainId !== ethChainId) {
-        return Err(makeSwapErrorRight({
-            message: `[getThorTradeQuote] - Unsupported chainId ${buyAsset.chainId}.`,
-            code: TradeQuoteError.UnsupportedChain,
-            details: { buyAssetChainId: buyAsset.chainId },
-        }));
-    }
-    const sellAssetChainId = sellAsset.chainId;
-    const buyAssetChainId = buyAsset.chainId;
-    const sellAssetFeeAssetId = deps.assertGetChainAdapter(sellAssetChainId).getFeeAssetId();
-    const sellAssetFeeAsset = sellAssetFeeAssetId ? deps.assetsById[sellAssetFeeAssetId] : undefined;
-    const buyAssetFeeAssetId = deps.assertGetChainAdapter(buyAssetChainId).getFeeAssetId();
-    const buyAssetFeeAsset = buyAssetFeeAssetId ? deps.assetsById[buyAssetFeeAssetId] : undefined;
-    if (!buyAssetFeeAsset) {
-        return Err(makeSwapErrorRight({
-            message: `[getThorTradeQuote] - No native buy asset found for ${buyAssetChainId}.`,
-            code: TradeQuoteError.InternalError,
-            details: { buyAssetChainId },
-        }));
-    }
-    if (!sellAssetFeeAsset) {
-        return Err(makeSwapErrorRight({
-            message: `[getThorTradeQuote] - No native buy asset found for ${sellAssetChainId}.`,
-            code: TradeQuoteError.InternalError,
-            details: { sellAssetChainId },
-        }));
-    }
+    const assertion = await assertValidL1ToLongtailTrade({ sellAsset, buyAsset, deps });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const { buyAssetFeeAsset } = assertion.unwrap();
     const l1Tol1RateInput = {
         ...input,
         buyAsset: buyAssetFeeAsset,
         sellAsset,
         sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmountCryptoBaseUnit,
     };
-    const maybeThorchainRates = await getL1RateOrQuote(l1Tol1RateInput, deps, streamingInterval, TradeType.L1ToLongTail, swapperName);
-    if (maybeThorchainRates.isErr())
-        return Err(maybeThorchainRates.unwrapErr());
-    const thorchainRates = maybeThorchainRates.unwrap();
-    let bestAggregator;
-    let quotedAmountOut;
-    const promises = await Promise.allSettled(thorchainRates.map(async (quote) => {
-        // A quote always has a first step
-        const onlyStep = getHopByIndex(quote, 0);
-        // Or well... it should.
-        if (!onlyStep) {
-            return Err(makeSwapErrorRight({
-                message: `[getL1ToLongtailRate] - First hop not found`,
-                code: TradeQuoteError.InternalError,
-            }));
-        }
-        const maybeBestAggregator = await getBestAggregator(buyAssetFeeAsset, getWrappedToken(buyAssetFeeAsset), getTokenFromAsset(buyAsset), onlyStep.buyAmountAfterFeesCryptoBaseUnit);
+    const maybeL1Rates = await getThorL1TradeRate(l1Tol1RateInput, deps, streamingInterval, TradeType.L1ToLongTail, swapperName);
+    if (maybeL1Rates.isErr())
+        return Err(maybeL1Rates.unwrapErr());
+    const maybeRates = await Promise.allSettled(maybeL1Rates.unwrap().map(async (quote) => {
+        const [step] = quote.steps;
+        const maybeBestAggregator = await getBestAggregator(buyAssetFeeAsset, getWrappedToken(buyAssetFeeAsset), getTokenFromAsset(buyAsset), step.buyAmountAfterFeesCryptoBaseUnit);
         if (maybeBestAggregator.isErr())
             return Err(maybeBestAggregator.unwrapErr());
-        const unwrappedResult = maybeBestAggregator.unwrap();
-        bestAggregator = unwrappedResult.bestAggregator;
-        quotedAmountOut = unwrappedResult.quotedAmountOut;
-        // No memo is returned upstream for rates
-        const updatedMemo = '';
+        const { quotedAmountOut } = maybeBestAggregator.unwrap();
         return Ok({
             ...quote,
-            memo: updatedMemo,
-            aggregator: bestAggregator,
+            // No memo is returned upstream for rates
+            memo: '',
             steps: quote.steps.map(s => ({
                 ...s,
                 buyAsset,
@@ -91,17 +38,7 @@ export const getL1ToLongtailRate = async (input, deps, streamingInterval, swappe
                 allowanceContract: TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET,
             })),
             isLongtail: true,
-            longtailData: {
-                L1ToLongtailExpectedAmountOut: quotedAmountOut.toString(),
-            },
         });
     }));
-    if (promises.every(promise => isRejected(promise) || isResolvedErr(promise))) {
-        return Err(makeSwapErrorRight({
-            message: '[getThorTradeQuote] - failed to get best aggregator',
-            code: TradeQuoteError.InternalError,
-        }));
-    }
-    const updatedQuotes = promises.filter(isFulfilled).map(element => element.value.unwrap());
-    return Ok(updatedQuotes);
+    return getSuccessfulTrades(maybeRates);
 };

package/dist/esm/swappers/ThorchainSwapper/utils/getLongtailQuote.d.ts

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

package/dist/esm/swappers/ThorchainSwapper/utils/getLongtailQuote.js

@@ -1,66 +1,90 @@
-import { ethChainId } from '@shapeshiftoss/caip';
-import { TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET, viemClientByChainId, } from '@shapeshiftoss/contracts';
+import { TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET } from '@shapeshiftoss/contracts';
+import { BigNumber, bn, bnOrZero } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
-import assert from 'assert';
-import { getL1RateOrQuote, TradeType } from '../../../thorchain-utils/index.js';
 import { TradeQuoteError } from '../../../types.js';
-import { makeSwapErrorRight } from '../../../utils.js';
+import { assertQuoteAddresses, makeSwapErrorRight } from '../../../utils/index.js';
+import { getSuccessfulTrades, getThorL1TradeQuote, getThorStepData, TradeType, } from '../../../utils/thorchain/index.js';
+import { assertValidLongtailToL1Trade } from './assertValidLongtailTrade.js';
 import { getBestAggregator } from './getBestAggregator.js';
 import { getTokenFromAsset, getWrappedToken } from './longTailHelpers.js';
+const LONGTAIL_TO_L1_DEADLINE_SECONDS = 600n;
 // This just uses UniswapV3 to get the longtail quote for now.
 export const getLongtailToL1Quote = async (input, deps, streamingInterval, swapperName) => {
     const { sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
-    /*
-      We only support ethereum longtail -> L1 swaps for now.
-      We can later add BSC via UniV3, or Avalanche (e.g. via PancakeSwap)
-    */
-    if (sellAsset.chainId !== ethChainId) {
-        return Err(makeSwapErrorRight({
-            message: `[getThorTradeQuote] - Unsupported chainId ${sellAsset.chainId}.`,
-            code: TradeQuoteError.UnsupportedChain,
-            details: { sellAssetChainId: sellAsset.chainId },
-        }));
-    }
-    const sellChainId = sellAsset.chainId;
-    const buyAssetFeeAssetId = deps.assertGetChainAdapter(sellChainId)?.getFeeAssetId();
-    const buyAssetFeeAsset = buyAssetFeeAssetId ? deps.assetsById[buyAssetFeeAssetId] : undefined;
-    if (!buyAssetFeeAsset) {
+    const addresses = assertQuoteAddresses(input);
+    if (addresses.isErr())
+        return Err(addresses.unwrapErr());
+    const { sendAddress: from } = addresses.unwrap();
+    const assertion = assertValidLongtailToL1Trade({ sellAsset, deps });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const { buyAssetFeeAsset } = assertion.unwrap();
+    const maybeBestAggregator = await getBestAggregator(buyAssetFeeAsset, getTokenFromAsset(sellAsset), getWrappedToken(buyAssetFeeAsset), sellAmountIncludingProtocolFeesCryptoBaseUnit);
+    if (maybeBestAggregator.isErr())
+        return Err(maybeBestAggregator.unwrapErr());
+    const { bestAggregator, quotedAmountOut } = maybeBestAggregator.unwrap();
+    // Paranoia - a zero expected amount out would likely lead to a loss of funds
+    if (quotedAmountOut <= 0n) {
         return Err(makeSwapErrorRight({
-            message: `[getThorTradeQuote] - No native buy asset found for ${sellChainId}.`,
+            message: '[getLongtailToL1Quote] - expected a positive amount out',
             code: TradeQuoteError.InternalError,
-            details: { sellAssetChainId: sellChainId },
         }));
     }
-    // TODO: use more than just UniswapV3, and also consider trianglar routes.
-    const publicClient = viemClientByChainId[sellChainId];
-    assert(publicClient !== undefined, `no public client found for chainId '${sellChainId}'`);
-    const maybeBestAggregator = await getBestAggregator(buyAssetFeeAsset, getTokenFromAsset(sellAsset), getWrappedToken(buyAssetFeeAsset), sellAmountIncludingProtocolFeesCryptoBaseUnit);
-    if (maybeBestAggregator.isErr()) {
-        return Err(maybeBestAggregator.unwrapErr());
-    }
-    const { bestAggregator, quotedAmountOut } = maybeBestAggregator.unwrap();
     const l1Tol1QuoteInput = {
         ...input,
         sellAsset: buyAssetFeeAsset,
         sellAmountIncludingProtocolFeesCryptoBaseUnit: quotedAmountOut.toString(),
     };
-    const thorchainQuotes = await getL1RateOrQuote(l1Tol1QuoteInput, deps, streamingInterval, TradeType.LongTailToL1, swapperName);
-    return thorchainQuotes.andThen(quotes => {
-        const updatedQuotes = quotes.map(q => ({
-            ...q,
-            aggregator: bestAggregator,
+    // The sell side is asserted to be ethereum above, so these are always evm quotes
+    const maybeL1Quotes = await getThorL1TradeQuote(l1Tol1QuoteInput, deps, streamingInterval, TradeType.LongTailToL1, swapperName);
+    if (maybeL1Quotes.isErr())
+        return Err(maybeL1Quotes.unwrapErr());
+    const maybeQuotes = await Promise.allSettled(maybeL1Quotes.unwrap().map(async (quote) => {
+        const amountOutMin = BigInt(bnOrZero(quotedAmountOut.toString())
+            .times(bn(1).minus(quote.slippageTolerancePercentageDecimal ?? 0))
+            .toFixed(0, BigNumber.ROUND_UP));
+        // Paranoia: ensure we have this to prevent sandwich attacks on the first step of a LongtailToL1 trade
+        if (amountOutMin <= 0n) {
+            return Err(makeSwapErrorRight({
+                message: '[getLongtailToL1Quote] - expected amountOutMin to be a positive amount',
+                code: TradeQuoteError.InternalError,
+            }));
+        }
+        // The deadline doubles as the THORChain deposit expiry, so it stays pinned to quote time rather
+        // than being refreshed at execution - a stale quote reverts instead of executing on newer terms
+        const deadline = BigInt(Math.floor(Date.now() / 1000)) + LONGTAIL_TO_L1_DEADLINE_SECONDS;
+        // Swap the direct deposit built by getThorL1TradeQuote for the aggregator swapIn we execute
+        const maybeStepData = await getThorStepData({
+            type: 'quote',
+            input,
+            from,
+            deps,
+            swapperName,
+            tradeType: TradeType.LongTailToL1,
+            sellAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            memo: quote.memo,
+            expiry: quote.expiry,
+            rawMemo: quote.memo,
+            longtail: { aggregator: bestAggregator, amountOutMin, deadline },
+        });
+        if (maybeStepData.isErr())
+            return Err(maybeStepData.unwrapErr());
+        const { data, transactionData, networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+        return Ok({
+            ...quote,
+            data: data ?? quote.data,
             // This logic will need to be updated to support multi-hop, if that's ever implemented for THORChain
-            steps: q.steps.map(s => ({
+            steps: quote.steps.map(s => ({
                 ...s,
                 sellAmountIncludingProtocolFeesCryptoBaseUnit,
                 sellAsset,
                 allowanceContract: TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET,
+                transactionData,
+                feeData: { ...s.feeData, networkFeeCryptoBaseUnit },
             })),
             isLongtail: true,
-            longtailData: {
-                longtailToL1ExpectedAmountOut: quotedAmountOut.toString(),
-            },
-        }));
-        return Ok(updatedQuotes);
-    });
+        });
+    }));
+    return getSuccessfulTrades(maybeQuotes);
 };

package/dist/esm/swappers/ThorchainSwapper/utils/getLongtailRate.d.ts

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

package/dist/esm/swappers/ThorchainSwapper/utils/getLongtailRate.js

@@ -1,66 +1,36 @@
-import { ethChainId } from '@shapeshiftoss/caip';
-import { TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET, viemClientByChainId, } from '@shapeshiftoss/contracts';
-import { Err, Ok } from '@sniptt/monads';
-import assert from 'assert';
-import { getL1RateOrQuote, TradeType } from '../../../thorchain-utils/index.js';
-import { TradeQuoteError } from '../../../types.js';
-import { makeSwapErrorRight } from '../../../utils.js';
+import { TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET } from '@shapeshiftoss/contracts';
+import { Err } from '@sniptt/monads';
+import { getThorL1TradeRate, TradeType } from '../../../utils/thorchain/index.js';
+import { assertValidLongtailToL1Trade } from './assertValidLongtailTrade.js';
 import { getBestAggregator } from './getBestAggregator.js';
 import { getTokenFromAsset, getWrappedToken } from './longTailHelpers.js';
 // This just uses UniswapV3 to get the longtail quote for now.
 export const getLongtailToL1Rate = async (input, deps, streamingInterval, swapperName) => {
     const { sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
-    /*
-      We only support ethereum longtail -> L1 swaps for now.
-      We can later add BSC via UniV3, or Avalanche (e.g. via PancakeSwap)
-    */
-    if (sellAsset.chainId !== ethChainId) {
-        return Err(makeSwapErrorRight({
-            message: `[getThorTradeQuote] - Unsupported chainId ${sellAsset.chainId}.`,
-            code: TradeQuoteError.UnsupportedChain,
-            details: { sellAssetChainId: sellAsset.chainId },
-        }));
-    }
-    const sellChainId = sellAsset.chainId;
-    const buyAssetFeeAssetId = deps.assertGetChainAdapter(sellChainId)?.getFeeAssetId();
-    const buyAssetFeeAsset = buyAssetFeeAssetId ? deps.assetsById[buyAssetFeeAssetId] : undefined;
-    if (!buyAssetFeeAsset) {
-        return Err(makeSwapErrorRight({
-            message: `[getThorTradeQuote] - No native buy asset found for ${sellChainId}.`,
-            code: TradeQuoteError.InternalError,
-            details: { sellAssetChainId: sellChainId },
-        }));
-    }
-    // TODO: use more than just UniswapV3, and also consider trianglar routes.
-    const publicClient = viemClientByChainId[sellChainId];
-    assert(publicClient !== undefined, `no public client found for chainId '${sellChainId}'`);
+    const assertion = assertValidLongtailToL1Trade({ sellAsset, deps });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const { buyAssetFeeAsset } = assertion.unwrap();
     const maybeBestAggregator = await getBestAggregator(buyAssetFeeAsset, getTokenFromAsset(sellAsset), getWrappedToken(buyAssetFeeAsset), sellAmountIncludingProtocolFeesCryptoBaseUnit);
     if (maybeBestAggregator.isErr()) {
         return Err(maybeBestAggregator.unwrapErr());
     }
-    const { bestAggregator, quotedAmountOut } = maybeBestAggregator.unwrap();
+    const { quotedAmountOut } = maybeBestAggregator.unwrap();
     const l1Tol1QuoteInput = {
         ...input,
         sellAsset: buyAssetFeeAsset,
         sellAmountIncludingProtocolFeesCryptoBaseUnit: quotedAmountOut.toString(),
     };
-    const thorchainRates = await getL1RateOrQuote(l1Tol1QuoteInput, deps, streamingInterval, TradeType.LongTailToL1, swapperName);
-    return thorchainRates.andThen(rates => {
-        const updatedRates = rates.map(q => ({
-            ...q,
-            aggregator: bestAggregator,
-            // This logic will need to be updated to support multi-hop, if that's ever implemented for THORChain
-            steps: q.steps.map(s => ({
-                ...s,
-                sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                sellAsset,
-                allowanceContract: TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET,
-            })),
-            isLongtail: true,
-            longtailData: {
-                longtailToL1ExpectedAmountOut: quotedAmountOut.toString(),
-            },
-        }));
-        return Ok(updatedRates);
-    });
+    const maybeL1Rates = await getThorL1TradeRate(l1Tol1QuoteInput, deps, streamingInterval, TradeType.LongTailToL1, swapperName);
+    return maybeL1Rates.map(rates => rates.map(rate => ({
+        ...rate,
+        // This logic will need to be updated to support multi-hop, if that's ever implemented for THORChain
+        steps: rate.steps.map(s => ({
+            ...s,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            sellAsset,
+            allowanceContract: TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET,
+        })),
+        isLongtail: true,
+    })));
 };

package/dist/esm/swappers/ThorchainSwapper/utils/getShortenedFinalAssetLimit/getShortenedFinalAssetLimit.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { addFinalAssetLimitToMemo } from '../../../../thorchain-utils/index.js';
+import { addFinalAssetLimitToMemo } from '../../../../utils/thorchain/index.js';
 import { THORCHAIN_AFFILIATE_NAME } from '../../constants.js';
 import { getShortenedFinalAssetLimit } from './getShortenedFinalAssetLimit.js';
 const RECEIVE_ADDRESS = '0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6';

package/dist/esm/swappers/ThorchainSwapper/utils/longTailHelpers.d.ts

@@ -3,8 +3,8 @@ import type { Asset } from '@shapeshiftoss/types';
 import { Token } from '@uniswap/sdk-core';
 import { FeeAmount } from '@uniswap/v3-sdk';
 import type { Address, GetContractReturnType, PublicClient } from 'viem';
-import type { ThornodePoolResponse } from '../../../thorchain-utils/index.js';
-import { TradeType } from '../../../thorchain-utils/index.js';
+import type { ThornodePoolResponse } from '../../../utils/thorchain/index.js';
+import { TradeType } from '../../../utils/thorchain/index.js';
 export declare const getWrappedToken: (nativeAsset: Asset) => Token;
 export declare const getTokenFromAsset: (asset: Asset) => Token;
 export declare function getTradeType(sellAssetPool: ThornodePoolResponse | undefined, buyAssetPool: ThornodePoolResponse | undefined, sellPoolId: string | undefined, buyPoolId: string | undefined): TradeType | undefined;

package/dist/esm/swappers/ThorchainSwapper/utils/longTailHelpers.js

@@ -3,7 +3,7 @@ import { I_UNISWAP_V3_POOL_ABI } from '@shapeshiftoss/contracts';
 import { Token } from '@uniswap/sdk-core';
 import { computePoolAddress, FeeAmount } from '@uniswap/v3-sdk';
 import { getAddress, getContract } from 'viem';
-import { TradeType } from '../../../thorchain-utils/index.js';
+import { TradeType } from '../../../utils/thorchain/index.js';
 import { WAVAX_TOKEN, WBNB_TOKEN, WETH_TOKEN } from './constants.js';
 export const getWrappedToken = (nativeAsset) => {
     switch (nativeAsset.chainId) {

package/dist/esm/swappers/ThorchainSwapper/utils/test-data/responses.d.ts

@@ -1,4 +1,4 @@
-import type { InboundAddressResponse, ThornodePoolResponse } from '../../../../thorchain-utils/index.js';
+import type { InboundAddressResponse, ThornodePoolResponse } from '../../../../utils/thorchain/index.js';
 export declare const btcThornodePool: ThornodePoolResponse;
 export declare const ethThornodePool: ThornodePoolResponse;
 export declare const foxThornodePool: ThornodePoolResponse;

package/dist/esm/swappers/ThorchainSwapper/utils/test-data/setupThorswapDeps.js

@@ -8,6 +8,10 @@ const feeData = {
         chainSpecific: { approvalFeeCryptoBaseUnit: '1', gasLimit: '1', gasPrice: '1' },
         tradeFee: '2',
     },
+    average: {
+        txFee: '400000',
+        chainSpecific: { gasLimit: '100000', gasPrice: '4' },
+    },
 };
 export const mockEvmChainAdapter = {
     getAddress: vi.fn(() => Promise.resolve('0xthisIsMyAddress')),

package/dist/esm/swappers/ZrxSwapper/ZrxSwapper.js

@@ -1,4 +1,4 @@
-import { executeEvmTransaction } from '../../utils.js';
+import { executeEvmTransaction } from '../../utils/index.js';
 export const zrxSwapper = {
     executeEvmTransaction,
 };