@shapeshiftoss/swapper 17.6.6 → 17.6.8

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

@@ -0,0 +1,29 @@
+import { UNISWAP_V3_POOL_FACTORY_CONTRACT_MAINNET, UNISWAP_V3_QUOTER_ABI, UNISWAP_V3_QUOTER_CONTRACT_MAINNET, viemClientByChainId, } from '@shapeshiftoss/contracts';
+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 { feeAmountToContractMap, generateV3PoolAddressesAcrossFeeRange, getContractDataByPool, getQuotedAmountOutByPool, selectBestRate, } from './longTailHelpers.js';
+export const getBestAggregator = async (buyAsset, sellToken, buyToken, sellAmountIncludingProtocolFeesCryptoBaseUnit) => {
+    const publicClient = viemClientByChainId[buyAsset.chainId];
+    assert(publicClient !== undefined, `no public client found for chainId '${buyAsset.chainId}'`);
+    const poolAddresses = generateV3PoolAddressesAcrossFeeRange(UNISWAP_V3_POOL_FACTORY_CONTRACT_MAINNET, sellToken, buyToken);
+    const poolContractData = getContractDataByPool(poolAddresses, publicClient, sellToken.address, buyToken.address);
+    const quoterContract = getContract({
+        abi: UNISWAP_V3_QUOTER_ABI,
+        address: UNISWAP_V3_QUOTER_CONTRACT_MAINNET,
+        client: publicClient,
+    });
+    const quotedAmountOutByPool = await getQuotedAmountOutByPool(poolContractData, BigInt(sellAmountIncludingProtocolFeesCryptoBaseUnit), quoterContract);
+    const [bestPool, quotedAmountOut] = selectBestRate(quotedAmountOutByPool);
+    const bestContractData = bestPool ? poolContractData.get(bestPool) : undefined;
+    const bestAggregator = bestContractData ? feeAmountToContractMap[bestContractData.fee] : undefined;
+    if (!bestAggregator || !quotedAmountOut) {
+        return Err(makeSwapErrorRight({
+            message: `[getThorTradeQuote] - No best aggregator contract found.`,
+            code: TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    return Ok({ bestAggregator, quotedAmountOut });
+};

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

@@ -0,0 +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>>;

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

@@ -0,0 +1,119 @@
+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 { 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 { addL1ToLongtailPartsToMemo } from './addL1ToLongtailPartsToMemo/addL1ToLongtailPartsToMemo.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 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) {
+            return Err(makeSwapErrorRight({
+                message: `[getL1ToLongtailQuote] - First hop not found`,
+                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,
+            aggregator: bestAggregator,
+            finalAssetAssetId: buyAsset.assetId,
+            finalAssetAmountOut: quotedAmountOut.toString(),
+            slippageBps: convertDecimalPercentageToBasisPoints(slippageTolerancePercentageDecimal ??
+                getDefaultSlippageDecimalPercentageForSwapper(swapperName)).toString(),
+            quotedMemo: quote.memo,
+            longtailTokens,
+            affiliate: getAffiliate(swapperName),
+        });
+        return Ok({
+            ...quote,
+            memo: updatedMemo,
+            aggregator: bestAggregator,
+            steps: quote.steps.map(s => ({
+                ...s,
+                buyAsset,
+                buyAmountAfterFeesCryptoBaseUnit: quotedAmountOut.toString(),
+                // 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,
+            })),
+            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);
+};

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

@@ -0,0 +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>>;

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

@@ -0,0 +1,107 @@
+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 { 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 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);
+        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 = '';
+        return Ok({
+            ...quote,
+            memo: updatedMemo,
+            aggregator: bestAggregator,
+            steps: quote.steps.map(s => ({
+                ...s,
+                buyAsset,
+                buyAmountAfterFeesCryptoBaseUnit: quotedAmountOut.toString(),
+                // 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,
+            })),
+            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);
+};

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

@@ -0,0 +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>>;

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

@@ -0,0 +1,66 @@
+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 { getBestAggregator } from './getBestAggregator.js';
+import { getTokenFromAsset, getWrappedToken } from './longTailHelpers.js';
+// 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) {
+        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 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,
+            // 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(updatedQuotes);
+    });
+};

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

@@ -0,0 +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>>;

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

@@ -0,0 +1,66 @@
+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 { 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 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 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);
+    });
+};

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

@@ -0,0 +1,5 @@
+export declare const getShortenedFinalAssetLimit: ({ maxMemoSize, memoWithoutFinalAssetLimit, finalAssetLimitWithManualSlippage, }: {
+    maxMemoSize: number;
+    memoWithoutFinalAssetLimit: string;
+    finalAssetLimitWithManualSlippage: string;
+}) => string;

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

@@ -0,0 +1,48 @@
+import assert from 'assert';
+// The THORChain aggregators expects two numbers at the end which are used at exponents in the contract
+// see _parseAmountOutMin in https://dashboard.tenderly.co/tx/mainnet/0xe16c61c114c5815555ec4342af390a1695d1cce431a8ff479bcc7d63f3d0b46a?trace=0.2.10
+// 7759345496513 => 775934549650000000000000
+const AGGREGATOR_EXPONENT_LENGTH = 2;
+// THORChain uses `big.ParseFloat` with `0` as a precision, resulting in a precision of 18 without the integer part
+// https://gitlab.com/thorchain/thornode/-/blob/v1.131.0/x/thorchain/memo/memo_parser.go#L190
+const THORCHAIN_PARSER_MAXIMUM_PRECISION = 18;
+export const getShortenedFinalAssetLimit = ({ maxMemoSize, memoWithoutFinalAssetLimit, finalAssetLimitWithManualSlippage, }) => {
+    // The min amount out should be at least 3 characters long (1 for the number and 2 for the exponent)
+    const MINIMUM_AMOUNT_OUT_LENGTH = 3;
+    const HYPOTHETICAL_EXPONENT = '01';
+    // We need to construct the memo with the minAmountOut at the end so we can calculate his bytes size
+    const unshortenedMemo = `${memoWithoutFinalAssetLimit}:${finalAssetLimitWithManualSlippage}${HYPOTHETICAL_EXPONENT}`;
+    const memoSizeLeft = maxMemoSize - unshortenedMemo.length;
+    let excessBytesToTrim = 0;
+    if (memoSizeLeft < 0) {
+        excessBytesToTrim = Math.abs(memoSizeLeft);
+    }
+    const shortenedMinAmountOutLength = finalAssetLimitWithManualSlippage.length + AGGREGATOR_EXPONENT_LENGTH - excessBytesToTrim;
+    // Paranoia check - can't shorten more than the initial min amount length
+    assert(shortenedMinAmountOutLength >= MINIMUM_AMOUNT_OUT_LENGTH, 'min amount chars length should be 3 or more');
+    // THORChain parser uses big.ParseFloat with `0` as a precision, resulting in a precision of 18 + the integer part, so we can't have more than 19 characters
+    // https://gitlab.com/thorchain/thornode/-/blob/v1.131.0/x/thorchain/memo/memo_parser.go#L190
+    if (shortenedMinAmountOutLength > THORCHAIN_PARSER_MAXIMUM_PRECISION + 1) {
+        excessBytesToTrim += shortenedMinAmountOutLength - (THORCHAIN_PARSER_MAXIMUM_PRECISION + 1);
+    }
+    else if (shortenedMinAmountOutLength <= THORCHAIN_PARSER_MAXIMUM_PRECISION + 1 &&
+        // Only add one byte if we don't trim for another reason before
+        !excessBytesToTrim) {
+        // If the length is less than the maximum precision, we need to remove one byte to the final asset amount because we absolutely need to add an exponent
+        // or the aggregator will multiply the number by 10 and then it will revert due to an higher expected amount than we can receive
+        excessBytesToTrim += 1;
+    }
+    const shortenedAmountOut = finalAssetLimitWithManualSlippage.substring(0, finalAssetLimitWithManualSlippage.length - excessBytesToTrim);
+    // Paranoia check - we should never have a 0 amount out
+    assert(shortenedAmountOut !== '0', 'expected final amount limit to be different than 0');
+    // The THORChain aggregators expects two numbers at the end which are used at exponents in the contract
+    const shouldPrependZero = excessBytesToTrim < 10;
+    const thorAggregatorExponential = shouldPrependZero
+        ? `0${excessBytesToTrim > 0 ? excessBytesToTrim : '1'}`
+        : excessBytesToTrim.toString();
+    assert(thorAggregatorExponential.length === 2, 'expected exponent to be 2 digits');
+    // The THORChain aggregators expects this amount to be an exponent, we need to add two numbers at the end which are used at exponents in the contract
+    const shortenedAmountOutWithTwoLastNumbersAsExponent = `${shortenedAmountOut}${thorAggregatorExponential}`;
+    assert(shortenedAmountOutWithTwoLastNumbersAsExponent.length <= THORCHAIN_PARSER_MAXIMUM_PRECISION + 1, 'expected shortenedAmountOut length to be less than thorchain maximum precision');
+    return shortenedAmountOutWithTwoLastNumbersAsExponent;
+};

package/dist/esm/swappers/ThorchainSwapper/utils/getShortenedFinalAssetLimit/getShortenedFinalAssetLimit.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,97 @@
+import { describe, expect, it } from 'vitest';
+import { addFinalAssetLimitToMemo } from '../../../../thorchain-utils/index.js';
+import { THORCHAIN_AFFILIATE_NAME } from '../../constants.js';
+import { getShortenedFinalAssetLimit } from './getShortenedFinalAssetLimit.js';
+const RECEIVE_ADDRESS = '0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6';
+// 178 bytes
+const BIG_ADDRESS = '0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb632DBc9Cf9E8FbC2ecF05Ed86Ca3096cF05Ed86Ca3096Cb60x32DBc9Cf9E8FbCebE1e0a2a3096C2ecF05Ed86Ca3096Cb632DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6';
+// 354 bytes
+const REALLY_BIG_ADDRESS = '0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb632DBc9Cf9E8FbC2ecF05Ed86Ca3096cF05Ed86Ca3096Cb60x32DBc9Cf9E8FbCebE1e0a2a3096C2ecF05Ed86Ca3096Cb632DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb632DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb632DBc9Cf9E8FbC2ecF05Ed86Ca3096cF05Ed86Ca3096Cb60x32DBc9Cf9E8FbCebE1e0a2a3096C2ecF05Ed86Ca3096Cb632DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6';
+const EXPECTED_AGGREGATOR_TWO_LAST_CHARS = 'd2';
+const SHORTENED_FINAL_ASSET_ADDRESS = 'a6df4741';
+const affiliateBps = '100';
+const expectedL1AmountOut = '42';
+describe('makeMemoWithShortenedfinalAssetLimit', () => {
+    it('should be 80 bytes if maxMemoSize is 80', () => {
+        const quotedMemo = `=:e:${RECEIVE_ADDRESS}:${expectedL1AmountOut}:ss:${affiliateBps}:${EXPECTED_AGGREGATOR_TWO_LAST_CHARS}:${SHORTENED_FINAL_ASSET_ADDRESS}`;
+        const finalAssetLimit = getShortenedFinalAssetLimit({
+            maxMemoSize: 80,
+            memoWithoutFinalAssetLimit: quotedMemo,
+            finalAssetLimitWithManualSlippage: '950875902132134123',
+        });
+        const modifiedMemoWithfinalAssetLimitOut = addFinalAssetLimitToMemo({
+            memo: quotedMemo,
+            finalAssetLimit,
+            affiliate: THORCHAIN_AFFILIATE_NAME,
+        });
+        expect(modifiedMemoWithfinalAssetLimitOut.length).toBe(80);
+        expect(finalAssetLimit).toBe(
+        // 95087590209 will be turned to 950875902000000000 using the last 2 bytes as exponents by the aggregator
+        `95087590209`);
+    });
+    it('shortened final asset amount length should be shortened by one if maxMemoSize is Infinity and final asset amount length is under or equal to 17', () => {
+        // Equals to 987,234,879,539,239,282.982983248234982348 ETH
+        const reallyL1BigAmount = '987234879539239282982983248234982348';
+        const quotedMemo = `=:e:${RECEIVE_ADDRESS}:${reallyL1BigAmount}:ss:${affiliateBps}:${EXPECTED_AGGREGATOR_TWO_LAST_CHARS}:${SHORTENED_FINAL_ASSET_ADDRESS}`;
+        const finalAssetLimit = getShortenedFinalAssetLimit({
+            maxMemoSize: Infinity,
+            memoWithoutFinalAssetLimit: quotedMemo,
+            finalAssetLimitWithManualSlippage: '95087590213213412',
+        });
+        // 950875902132134101 will be turned to 95087590213213410 using the last 2 bytes as exponents by the aggregator
+        const expectedFinalAssetLimit = `950875902132134101`;
+        expect(finalAssetLimit).toBe(expectedFinalAssetLimit);
+    });
+    it('shortened final asset amount should be shortened by 1 if maxMemoSize is Infinity and final asset amount length equal to 18', () => {
+        // Equals to 987,234,879,539,239,282.982983248234982348 ETH
+        const reallyL1BigAmount = '987234879539239282982983248234982348';
+        const quotedMemo = `=:e:${RECEIVE_ADDRESS}:${reallyL1BigAmount}:ss:${affiliateBps}:${EXPECTED_AGGREGATOR_TWO_LAST_CHARS}:${SHORTENED_FINAL_ASSET_ADDRESS}`;
+        const finalAssetLimit = getShortenedFinalAssetLimit({
+            maxMemoSize: Infinity,
+            memoWithoutFinalAssetLimit: quotedMemo,
+            finalAssetLimitWithManualSlippage: '950875902132134122',
+        });
+        // 9508759021321341201 will be turned to 950875902132134120 using the last 2 bytes as exponents by the aggregator
+        const expectedFinalAssetLimit = `9508759021321341201`;
+        expect(finalAssetLimit).toBe(expectedFinalAssetLimit);
+    });
+    it('shortened final asset amount should be shortened by 2 if maxMemoSize is Infinity and final asset amount length equal to 19', () => {
+        // Equals to 987,234,879,539,239,282.982983248234982348 ETH
+        const reallyL1BigAmount = '987234879539239282982983248234982348';
+        const quotedMemo = `=:e:${RECEIVE_ADDRESS}:${reallyL1BigAmount}:ss:${affiliateBps}:${EXPECTED_AGGREGATOR_TWO_LAST_CHARS}:${SHORTENED_FINAL_ASSET_ADDRESS}`;
+        const finalAssetLimit = getShortenedFinalAssetLimit({
+            maxMemoSize: Infinity,
+            memoWithoutFinalAssetLimit: quotedMemo,
+            finalAssetLimitWithManualSlippage: '9508759021321341223',
+        });
+        // 9508759021321341202 will be turned to 9508759021321341200 using the last 2 bytes as exponents by the aggregator
+        const expectedFinalAssetLimit = `9508759021321341202`;
+        expect(finalAssetLimit).toBe(expectedFinalAssetLimit);
+    });
+    it('should be under or equal to 220 bytes if maxMemoSize is 220 and memo length is close to 220', () => {
+        // 205 bytes
+        const quotedMemo = `=:e:${BIG_ADDRESS}:${expectedL1AmountOut}:ss:${affiliateBps}:${EXPECTED_AGGREGATOR_TWO_LAST_CHARS}:${SHORTENED_FINAL_ASSET_ADDRESS}`;
+        const finalAssetLimit = getShortenedFinalAssetLimit({
+            maxMemoSize: 220,
+            memoWithoutFinalAssetLimit: quotedMemo,
+            finalAssetLimitWithManualSlippage: '950875902132134123',
+        });
+        const modifiedMemoWithfinalAssetLimitOut = addFinalAssetLimitToMemo({
+            memo: quotedMemo,
+            finalAssetLimit,
+            affiliate: THORCHAIN_AFFILIATE_NAME,
+        });
+        expect(modifiedMemoWithfinalAssetLimitOut.length).toBeLessThanOrEqual(220);
+        expect(finalAssetLimit).toBe(
+        // 950875902132105 will be turned to 950875902132100000 using the last 2 bytes as exponents by the aggregator
+        `950875902132105`);
+    });
+    it('should be throwing if length cant be achieved because exponent will be bigger than expected', () => {
+        const quotedMemo = `=:e:${REALLY_BIG_ADDRESS}:${expectedL1AmountOut}:ss:${affiliateBps}:${EXPECTED_AGGREGATOR_TWO_LAST_CHARS}:${SHORTENED_FINAL_ASSET_ADDRESS}`;
+        expect(() => getShortenedFinalAssetLimit({
+            maxMemoSize: 220,
+            memoWithoutFinalAssetLimit: quotedMemo,
+            finalAssetLimitWithManualSlippage: '950875902132134123',
+        })).toThrow('min amount chars length should be 3 or more');
+    });
+});

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

@@ -0,0 +1,2 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+export declare const getUniqueAddressSubstring: (destinationAssetId: AssetId, longTailAssetIds: AssetId[]) => AssetId;

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

@@ -0,0 +1,23 @@
+export const getUniqueAddressSubstring = (destinationAssetId, longTailAssetIds) => {
+    const MINIMUM_UNIQUE_SUBSTRING = 2;
+    let maybeShortenedDestinationAddress = destinationAssetId;
+    const substringsCount = {};
+    for (let length = MINIMUM_UNIQUE_SUBSTRING; length <= destinationAssetId.length - 2; length++) {
+        const currentSubstring = destinationAssetId.slice(-length);
+        substringsCount[currentSubstring] = 0;
+    }
+    longTailAssetIds.forEach(assetId => {
+        Object.keys(substringsCount).forEach(substring => {
+            if (assetId.includes(substring)) {
+                substringsCount[substring] += 1;
+            }
+        });
+    });
+    for (const [substring, count] of Object.entries(substringsCount)) {
+        if (count === 1) {
+            maybeShortenedDestinationAddress = substring;
+            break;
+        }
+    }
+    return maybeShortenedDestinationAddress;
+};

package/dist/esm/swappers/ThorchainSwapper/utils/getUniqueAddressSubstring/getUniqueAddressSubstring.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,36 @@
+import { ethChainId, toAssetId } from '@shapeshiftoss/caip';
+import { describe, expect, it } from 'vitest';
+import { getUniqueAddressSubstring } from './getUniqueAddressSubstring.js';
+const FINAL_ASSET_ASSETID = toAssetId({
+    chainId: ethChainId,
+    assetReference: '0x8a65ac0E23F31979db06Ec62Af62b432a6dF4741',
+    assetNamespace: 'erc20',
+});
+const COLLIDING_FINAL_ASSETID = toAssetId({
+    chainId: ethChainId,
+    assetReference: '0xa0b86991c6218b36c1d19d4a2e9eb0ce36dF4741',
+    assetNamespace: 'erc20',
+});
+const BIGGER_COLLIDING_FINAL_ASSETID = toAssetId({
+    chainId: ethChainId,
+    assetReference: '0xa0b86991c6218b36c1d19d4a2e9eb032a6dF4741',
+    assetNamespace: 'erc20',
+});
+const SHORTENED_FINAL_ASSET_ADDRESS = 'a6df4741';
+const BIGGER_SHORTENED_FINAL_ASSET_ADDRESS = '432a6df4741';
+const THORCHAIN_ASSETIDS_ONE_COLLISION = [FINAL_ASSET_ASSETID, COLLIDING_FINAL_ASSETID];
+const THORCHAIN_ASSETIDS_TWO_COLLISION = [
+    FINAL_ASSET_ASSETID,
+    COLLIDING_FINAL_ASSETID,
+    BIGGER_COLLIDING_FINAL_ASSETID,
+];
+describe('getUniqueAddressSubstring', () => {
+    it('should get the shorter unique address substring', () => {
+        const substring = getUniqueAddressSubstring(FINAL_ASSET_ASSETID, THORCHAIN_ASSETIDS_ONE_COLLISION);
+        expect(substring).toBe(SHORTENED_FINAL_ASSET_ADDRESS);
+    });
+    it('should get the shorter unique address substring with a bigger colliding address', () => {
+        const substring = getUniqueAddressSubstring(FINAL_ASSET_ASSETID, THORCHAIN_ASSETIDS_TWO_COLLISION);
+        expect(substring).toBe(BIGGER_SHORTENED_FINAL_ASSET_ADDRESS);
+    });
+});