@shapeshiftoss/swapper 17.8.0 → 19.0.0

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

@@ -0,0 +1,71 @@
+import { ethChainId } from '@shapeshiftoss/caip';
+import { viemClientByChainId } from '@shapeshiftoss/contracts';
+import { Err, Ok } from '@sniptt/monads';
+import { TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
+// We only support ethereum longtail -> L1 swaps for now.
+// We can later add BSC via UniV3, or Avalanche (e.g. via PancakeSwap)
+export const assertValidLongtailToL1Trade = ({ sellAsset, deps, }) => {
+    if (sellAsset.chainId !== ethChainId) {
+        return Err(makeSwapErrorRight({
+            message: `[getThorTradeQuote] - Unsupported chainId ${sellAsset.chainId}.`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { sellAssetChainId: sellAsset.chainId },
+        }));
+    }
+    const buyAssetFeeAssetId = deps.assertGetChainAdapter(sellAsset.chainId)?.getFeeAssetId();
+    const buyAssetFeeAsset = buyAssetFeeAssetId ? deps.assetsById[buyAssetFeeAssetId] : undefined;
+    if (!buyAssetFeeAsset) {
+        return Err(makeSwapErrorRight({
+            message: `[getThorTradeQuote] - No native buy asset found for ${sellAsset.chainId}.`,
+            code: TradeQuoteError.InternalError,
+            details: { sellAssetChainId: sellAsset.chainId },
+        }));
+    }
+    // TODO: use more than just UniswapV3, and also consider trianglar routes.
+    if (viemClientByChainId[sellAsset.chainId] === undefined) {
+        return Err(makeSwapErrorRight({
+            message: `no public client found for chainId '${sellAsset.chainId}'`,
+            code: TradeQuoteError.InternalError,
+        }));
+    }
+    return Ok({ buyAssetFeeAsset });
+};
+// We only support L1 -> ethereum longtail swaps for now.
+export const assertValidL1ToLongtailTrade = async ({ sellAsset, buyAsset, deps, }) => {
+    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 },
+        }));
+    }
+    if (buyAsset.chainId !== ethChainId) {
+        return Err(makeSwapErrorRight({
+            message: `[getThorTradeQuote] - Unsupported chainId ${buyAsset.chainId}.`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { buyAssetChainId: buyAsset.chainId },
+        }));
+    }
+    const sellAssetFeeAssetId = deps.assertGetChainAdapter(sellAsset.chainId).getFeeAssetId();
+    const sellAssetFeeAsset = sellAssetFeeAssetId ? deps.assetsById[sellAssetFeeAssetId] : undefined;
+    const buyAssetFeeAssetId = deps.assertGetChainAdapter(buyAsset.chainId).getFeeAssetId();
+    const buyAssetFeeAsset = buyAssetFeeAssetId ? deps.assetsById[buyAssetFeeAssetId] : undefined;
+    if (!buyAssetFeeAsset) {
+        return Err(makeSwapErrorRight({
+            message: `[getThorTradeQuote] - No native buy asset found for ${buyAsset.chainId}.`,
+            code: TradeQuoteError.InternalError,
+            details: { buyAssetChainId: buyAsset.chainId },
+        }));
+    }
+    if (!sellAssetFeeAsset) {
+        return Err(makeSwapErrorRight({
+            message: `[getThorTradeQuote] - No native buy asset found for ${sellAsset.chainId}.`,
+            code: TradeQuoteError.InternalError,
+            details: { sellAssetChainId: sellAsset.chainId },
+        }));
+    }
+    return Ok({ buyAssetFeeAsset, longtailTokens });
+};

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

@@ -0,0 +1,12 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight, SwapperDeps } from '../../../types.js';
+import { TradeType } from '../../../utils/thorchain/index.js';
+export declare const assertValidTrade: ({ sellAsset, buyAsset, deps, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+    deps: SwapperDeps;
+}) => Promise<Result<{
+    tradeType: TradeType;
+    streamingInterval: number;
+}, SwapErrorRight>>;

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

@@ -0,0 +1,41 @@
+import { Err, Ok } from '@sniptt/monads';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
+import { getPoolDetails, TradeType } from '../../../utils/thorchain/index.js';
+import { THORCHAIN_SUPPORTED_CHAIN_IDS } from '../constants.js';
+import { getTradeType } from './longTailHelpers.js';
+export const assertValidTrade = async ({ sellAsset, buyAsset, deps, }) => {
+    if (!THORCHAIN_SUPPORTED_CHAIN_IDS.includes(sellAsset.chainId) ||
+        !THORCHAIN_SUPPORTED_CHAIN_IDS.includes(buyAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: 'Unsupported chain',
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    const poolDetails = await getPoolDetails({
+        buyAsset,
+        sellAsset,
+        url: `${deps.config.VITE_THORCHAIN_NODE_URL}/thorchain/pools`,
+        swapperName: SwapperName.Thorchain,
+    });
+    if (poolDetails.isErr())
+        return Err(poolDetails.unwrapErr());
+    const { buyPool, buyPoolId, sellPool, sellPoolId, streamingInterval } = poolDetails.unwrap();
+    const tradeType = deps.config.VITE_FEATURE_THORCHAINSWAP_LONGTAIL
+        ? getTradeType(sellPool, buyPool, sellPoolId, buyPoolId)
+        : TradeType.L1ToL1;
+    if (tradeType === undefined) {
+        return Err(makeSwapErrorRight({
+            message: 'Unknown trade type',
+            code: TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    if ((!buyPoolId && tradeType !== TradeType.L1ToLongTail) ||
+        (!sellPoolId && tradeType !== TradeType.LongTailToL1)) {
+        return Err(makeSwapErrorRight({
+            message: 'Unsupported trade pair',
+            code: TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    return Ok({ tradeType, streamingInterval });
+};

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

@@ -3,7 +3,7 @@ import { Err, Ok } from '@sniptt/monads';
 import assert from 'assert';
 import { getContract } from 'viem';
 import { TradeQuoteError } from '../../../types.js';
-import { makeSwapErrorRight } from '../../../utils.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
 import { feeAmountToContractMap, generateV3PoolAddressesAcrossFeeRange, getContractDataByPool, getQuotedAmountOutByPool, selectBestRate, } from './longTailHelpers.js';
 export const getBestAggregator = async (buyAsset, sellToken, buyToken, sellAmountIncludingProtocolFeesCryptoBaseUnit) => {
     const publicClient = viemClientByChainId[buyAsset.chainId];

package/dist/esm/swappers/ThorchainSwapper/utils/getL1ToLongtailQuote.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 getL1ToLongtailQuote: (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 getL1ToLongtailQuote: (input: ThorTradeQuoteInput, deps: SwapperDeps, streamingInterval: number, swapperName: SwapperName) => Promise<Result<ThorTradeQuote[], SwapErrorRight>>;

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,92 @@
-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,
+            // The aggregator swapIn deadline is tighter than the daemon quote expiry
+            deadline: Math.min(quote.deadline, Number(deadline) * 1000),
+            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>>;