@shapeshiftoss/swapper 17.6.6 → 17.6.7

package/dist/esm/swappers/ThorchainSwapper/generated/generatedTradableAssetMap.json

@@ -0,0 +1,45 @@
+{
+    "AVAX.AVAX": "eip155:43114/slip44:60",
+    "AVAX.SOL-0XFE6B19286885A4F7F55ADAD09C3CD1F906D2478F": "eip155:43114/erc20:0xfe6b19286885a4f7f55adad09c3cd1f906d2478f",
+    "AVAX.USDC-0XB97EF9EF8734C71904D8002F8B6BC66DD9C48A6E": "eip155:43114/erc20:0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e",
+    "AVAX.USDT-0X9702230A8EA53601F5CD2DC00FDBC13D4DF4A8C7": "eip155:43114/erc20:0x9702230a8ea53601f5cd2dc00fdbc13d4df4a8c7",
+    "BASE.CBBTC-0XCBB7C0000AB88B473B1F5AFD9EF808440EED33BF": "eip155:8453/erc20:0xcbb7c0000ab88b473b1f5afd9ef808440eed33bf",
+    "BASE.ETH": "eip155:8453/slip44:60",
+    "BASE.USDC-0X833589FCD6EDB6E08F4C7C32D4F71B54BDA02913": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+    "BASE.VVV-0XACFE6019ED1A7DC6F7B508C02D1B04EC88CC21BF": "eip155:8453/erc20:0xacfe6019ed1a7dc6f7b508c02d1b04ec88cc21bf",
+    "BCH.BCH": "bip122:000000000000000000651ef99cb9fcbe/slip44:145",
+    "BSC.BNB": "eip155:56/slip44:60",
+    "BSC.BTCB-0X7130D2A12B9BCBFAE4F2634D864A1EE1CE3EAD9C": "eip155:56/erc20:0x7130d2a12b9bcbfae4f2634d864a1ee1ce3ead9c",
+    "BSC.BUSD-0XE9E7CEA3DEDCA5984780BAFC599BD69ADD087D56": "eip155:56/erc20:0xe9e7cea3dedca5984780bafc599bd69add087d56",
+    "BSC.ETH-0X2170ED0880AC9A755FD29B2688956BD959F933F8": "eip155:56/erc20:0x2170ed0880ac9a755fd29b2688956bd959f933f8",
+    "BSC.TWT-0X4B0F1812E5DF2A09796481FF14017E6005508003": "eip155:56/erc20:0x4b0f1812e5df2a09796481ff14017e6005508003",
+    "BSC.USDC-0X8AC76A51CC950D9822D68B83FE1AD97B32CD580D": "eip155:56/erc20:0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d",
+    "BSC.USDT-0X55D398326F99059FF775485246999027B3197955": "eip155:56/erc20:0x55d398326f99059ff775485246999027b3197955",
+    "BTC.BTC": "bip122:000000000019d6689c085ae165831e93/slip44:0",
+    "DOGE.DOGE": "bip122:00000000001a91e3dace36e2be3bf030/slip44:3",
+    "ETH.AAVE-0X7FC66500C84A76AD7E9C93437BFC5AC33E2DDAE9": "eip155:1/erc20:0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9",
+    "ETH.DAI-0X6B175474E89094C44DA98B954EEDEAC495271D0F": "eip155:1/erc20:0x6b175474e89094c44da98b954eedeac495271d0f",
+    "ETH.DPI-0X1494CA1F11D487C2BBE4543E90080AEBA4BA3C2B": "eip155:1/erc20:0x1494ca1f11d487c2bbe4543e90080aeba4ba3c2b",
+    "ETH.ETH": "eip155:1/slip44:60",
+    "ETH.FOX-0XC770EEFAD204B5180DF6A14EE197D99D808EE52D": "eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d",
+    "ETH.GUSD-0X056FD409E1D7A124BD7017459DFEA2F387B6D5CD": "eip155:1/erc20:0x056fd409e1d7a124bd7017459dfea2f387b6d5cd",
+    "ETH.LINK-0X514910771AF9CA656AF840DFF83E8264ECF986CA": "eip155:1/erc20:0x514910771af9ca656af840dff83e8264ecf986ca",
+    "ETH.LUSD-0X5F98805A4E8BE255A32880FDEC7F6728C6568BA0": "eip155:1/erc20:0x5f98805a4e8be255a32880fdec7f6728c6568ba0",
+    "ETH.RAZE-0X5EAA69B29F99C84FE5DE8200340B4E9B4AB38EAC": "eip155:1/erc20:0x5eaa69b29f99c84fe5de8200340b4e9b4ab38eac",
+    "ETH.SNX-0XC011A73EE8576FB46F5E1C5751CA3B9FE0AF2A6F": "eip155:1/erc20:0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f",
+    "ETH.TGT-0X108A850856DB3F85D0269A2693D896B394C80325": "eip155:1/erc20:0x108a850856db3f85d0269a2693d896b394c80325",
+    "ETH.THOR-0XA5F2211B9B8170F694421F2046281775E8468044": "eip155:1/erc20:0xa5f2211b9b8170f694421f2046281775e8468044",
+    "ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48": "eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+    "ETH.USDP-0X8E870D67F660D95D5BE530380D0EC0BD388289E1": "eip155:1/erc20:0x8e870d67f660d95d5be530380d0ec0bd388289e1",
+    "ETH.USDT-0XDAC17F958D2EE523A2206206994597C13D831EC7": "eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7",
+    "ETH.VTHOR-0X815C23ECA83261B6EC689B60CC4A58B54BC24D8D": "eip155:1/erc20:0x815c23eca83261b6ec689b60cc4a58b54bc24d8d",
+    "ETH.WBTC-0X2260FAC5E5542A773AA44FBCFEDF7C193BC2C599": "eip155:1/erc20:0x2260fac5e5542a773aa44fbcfedf7c193bc2c599",
+    "ETH.XDEFI-0X72B886D09C117654AB7DA13A14D603001DE0B777": "eip155:1/erc20:0x72b886d09c117654ab7da13a14d603001de0b777",
+    "ETH.XRUNE-0X69FA0FEE221AD11012BAB0FDB45D444D3D2CE71C": "eip155:1/erc20:0x69fa0fee221ad11012bab0fdb45d444d3d2ce71c",
+    "ETH.YFI-0X0BC529C00C6401AEF6D220BE8C6EA1667F6AD93E": "eip155:1/erc20:0x0bc529c00c6401aef6d220be8c6ea1667f6ad93e",
+    "GAIA.ATOM": "cosmos:cosmoshub-4/slip44:118",
+    "LTC.LTC": "bip122:12a765e31ffd4059bada1e25190f6e98/slip44:2",
+    "THOR.RUJI": "cosmos:thorchain-1/slip44:ruji",
+    "THOR.TCY": "cosmos:thorchain-1/slip44:tcy",
+    "THOR.RUNE": "cosmos:thorchain-1/slip44:931"
+}

package/dist/esm/swappers/ThorchainSwapper/getTradeQuote/getTradeQuote.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 } from '../../../types.js';
+export declare const getTradeQuote: (input: CommonTradeQuoteInput, deps: SwapperDeps) => Promise<Result<ThorTradeQuote[], SwapErrorRight>>;

package/dist/esm/swappers/ThorchainSwapper/getTradeQuote/getTradeQuote.js

@@ -0,0 +1,61 @@
+import { assertUnreachable } from '@shapeshiftoss/utils';
+import { Err } from '@sniptt/monads';
+import { getL1RateOrQuote, getPoolDetails, TradeType } from '../../../thorchain-utils/index.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils.js';
+import { THORCHAIN_SUPPORTED_CHAIN_IDS } from '../constants.js';
+import { getL1ToLongtailQuote } from '../utils/getL1ToLongtailQuote.js';
+import { getLongtailToL1Quote } from '../utils/getLongtailQuote.js';
+import { getTradeType } from '../utils/longTailHelpers.js';
+export const getTradeQuote = async (input, deps) => {
+    const thorchainSwapLongtailEnabled = deps.config.VITE_FEATURE_THORCHAINSWAP_LONGTAIL;
+    const thorchainSwapL1ToLongtailEnabled = deps.config.VITE_FEATURE_THORCHAINSWAP_L1_TO_LONGTAIL;
+    const { sellAsset, buyAsset } = input;
+    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 = thorchainSwapLongtailEnabled
+        ? 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,
+        }));
+    }
+    switch (tradeType) {
+        case TradeType.L1ToL1:
+            return getL1RateOrQuote(input, deps, streamingInterval, tradeType, SwapperName.Thorchain);
+        case TradeType.LongTailToL1:
+            return getLongtailToL1Quote(input, deps, streamingInterval, SwapperName.Thorchain);
+        case TradeType.L1ToLongTail:
+            if (!thorchainSwapL1ToLongtailEnabled) {
+                return Err(makeSwapErrorRight({ message: 'Not implemented yet' }));
+            }
+            return getL1ToLongtailQuote(input, deps, streamingInterval, SwapperName.Thorchain);
+        case TradeType.LongTailToLongTail:
+            return Err(makeSwapErrorRight({ message: 'Not implemented yet' }));
+        default:
+            return assertUnreachable(tradeType);
+    }
+};

package/dist/esm/swappers/ThorchainSwapper/getTradeQuote/getTradeQuote.test.d.ts

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

package/dist/esm/swappers/ThorchainSwapper/getTradeQuote/getTradeQuote.test.js

@@ -0,0 +1,208 @@
+import { Ok } from '@sniptt/monads';
+import { omit } from 'lodash';
+import { describe, expect, it, vi } from 'vitest';
+import { evm, thorService, TradeType } from '../../../thorchain-utils/index.js';
+import { SwapperName } from '../../../types.js';
+import { ETH, FOX_MAINNET } from '../../utils/test-data/assets.js';
+import { setupQuote } from '../../utils/test-data/setupSwapQuote.js';
+import { mockInboundAddresses, thornodePools } from '../utils/test-data/responses.js';
+import { mockEvmChainAdapter } from '../utils/test-data/setupThorswapDeps.js';
+import { getTradeQuote } from './getTradeQuote.js';
+const mockedGetThorTxInfo = vi.mocked(evm.getThorTxData);
+const mockedThorService = vi.mocked(thorService);
+const mocks = vi.hoisted(() => ({
+    get: vi.fn(),
+    post: vi.fn(),
+}));
+vi.mock('../../../thorchain-utils/evm/getThorTxData');
+vi.mock('../../../thorchain-utils/service', () => {
+    const mockAxios = {
+        default: {
+            create: vi.fn(() => ({
+                get: mocks.get,
+                post: mocks.post,
+            })),
+        },
+    };
+    return {
+        thorService: mockAxios.default.create(),
+    };
+});
+vi.mock('@/config', () => {
+    return {
+        getConfig: () => ({
+            VITE_THORCHAIN_NODE_URL: '',
+        }),
+    };
+});
+const expectedQuoteResponse = [
+    {
+        quoteOrRate: 'quote',
+        receiveAddress: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+        affiliateBps: '0',
+        isStreaming: false,
+        recommendedMinimumCryptoBaseUnit: '10000000000',
+        rate: '143505.61489594191334131621',
+        data: '0x',
+        router: '0x3624525075b88B24ecc29CE226b0CEc1fFcB6976',
+        vault: '0x06828ac8dbf4cc9e5f363ead14629c9b330c0f5c',
+        memo: '=:ETH.ETH:0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6:9786345:ss:0',
+        tradeType: TradeType.L1ToL1,
+        slippageTolerancePercentageDecimal: '0.04357',
+        expiry: 1713710808,
+        swapperName: SwapperName.Thorchain,
+        steps: [
+            {
+                estimatedExecutionTimeMs: 1600000,
+                allowanceContract: '0x3624525075b88B24ecc29CE226b0CEc1fFcB6976',
+                sellAmountIncludingProtocolFeesCryptoBaseUnit: '713014679420',
+                buyAmountBeforeFeesCryptoBaseUnit: '5442880880000000000',
+                buyAmountAfterFeesCryptoBaseUnit: '102321610000000000',
+                feeData: {
+                    protocolFees: {
+                        [ETH.assetId]: {
+                            amountCryptoBaseUnit: '5340559270000000000',
+                            requiresBalance: false,
+                            asset: ETH,
+                        },
+                    },
+                    networkFeeCryptoBaseUnit: '400000',
+                },
+                rate: '143505.61489594191334131621',
+                source: SwapperName.Thorchain,
+                buyAsset: ETH,
+                sellAsset: FOX_MAINNET,
+                accountNumber: 0,
+                thorchainSpecific: {
+                    maxStreamingQuantity: undefined,
+                },
+            },
+        ],
+    },
+    {
+        quoteOrRate: 'quote',
+        receiveAddress: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+        affiliateBps: '0',
+        isStreaming: true,
+        recommendedMinimumCryptoBaseUnit: '10000000000',
+        rate: '157530.57158846677816130059',
+        data: '0x',
+        router: '0x3624525075b88B24ecc29CE226b0CEc1fFcB6976',
+        vault: '0x06828ac8dbf4cc9e5f363ead14629c9b330c0f5c',
+        memo: '=:ETH.ETH:0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6:0/10/0:ss:0',
+        tradeType: TradeType.L1ToL1,
+        slippageTolerancePercentageDecimal: undefined,
+        expiry: 1713710808,
+        swapperName: SwapperName.Thorchain,
+        steps: [
+            {
+                estimatedExecutionTimeMs: 1600000,
+                allowanceContract: '0x3624525075b88B24ecc29CE226b0CEc1fFcB6976',
+                sellAmountIncludingProtocolFeesCryptoBaseUnit: '713014679420',
+                buyAmountBeforeFeesCryptoBaseUnit: '5452880880000000000',
+                buyAmountAfterFeesCryptoBaseUnit: '112321610000000000',
+                feeData: {
+                    protocolFees: {
+                        [ETH.assetId]: {
+                            amountCryptoBaseUnit: '5340559270000000000',
+                            requiresBalance: false,
+                            asset: ETH,
+                        },
+                    },
+                    networkFeeCryptoBaseUnit: '400000',
+                },
+                rate: '157530.57158846677816130059',
+                source: `${SwapperName.Thorchain} • Streaming`,
+                buyAsset: ETH,
+                sellAsset: FOX_MAINNET,
+                accountNumber: 0,
+                thorchainSpecific: {
+                    maxStreamingQuantity: undefined,
+                },
+            },
+        ],
+    },
+];
+describe('getTradeQuote', () => {
+    mockedGetThorTxInfo.mockReturnValue(Promise.resolve({
+        data: '0x',
+        router: '0x3624525075b88B24ecc29CE226b0CEc1fFcB6976',
+        vault: '0x06828ac8dbf4cc9e5f363ead14629c9b330c0f5c',
+    }));
+    const { quoteInput } = setupQuote();
+    it('should get a thorchain quote for a thorchain trade', async () => {
+        mockedThorService.get.mockImplementation((url) => {
+            switch (url) {
+                case '/thorchain/pools':
+                    return Promise.resolve(Ok({ data: thornodePools }));
+                case '/thorchain/inbound_addresses':
+                    return Promise.resolve(Ok({ data: mockInboundAddresses }));
+                default: {
+                    // '/lcd/thorchain/quote/swap/<swapQueryParams>' fallthrough
+                    const mockThorQuote = {
+                        data: {
+                            expected_amount_out: '10232161',
+                            expiry: 1713710808,
+                            fees: {
+                                affiliate: '0',
+                                asset: 'ETH.ETH',
+                                liquidity: '533215927',
+                                outbound: '1200000',
+                                slippage_bps: 435,
+                                total: '534055927',
+                                total_bps: 348,
+                            },
+                            inbound_address: 'bc1qucjrczghvwl5d66klz6npv7tshkpwpzlw0zzj8',
+                            notes: 'First output should be to inbound_address, second output should be change back to self, third output should be OP_RETURN, limited to 80 bytes. Do not send below the dust threshold. Do not use exotic spend scripts, locks or address formats (P2WSH with Bech32 address format preferred).',
+                            outbound_delay_blocks: 575,
+                            outbound_delay_seconds: 6900,
+                            warning: 'Do not cache this response. Do not send funds after the expiry.',
+                            memo: '=:ETH.ETH:0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6::ss:0',
+                            router: '0x3624525075b88B24ecc29CE226b0CEc1fFcB6976',
+                            streaming_swap_seconds: 400,
+                            total_swap_seconds: 1600,
+                            inbound_confirmation_seconds: 600,
+                            recommended_min_amount_in: '1',
+                        },
+                    };
+                    if (url.includes('streaming_interval')) {
+                        mockThorQuote.data.expected_amount_out = '11232161';
+                        mockThorQuote.data.fees.slippage_bps = 420;
+                        mockThorQuote.data.memo =
+                            '=:ETH.ETH:0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6:0/10/0:ss:0';
+                    }
+                    return Promise.resolve(Ok(mockThorQuote));
+                }
+            }
+        });
+        const input = {
+            ...quoteInput,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit: '713014679420',
+            buyAsset: ETH,
+            sellAsset: FOX_MAINNET,
+            slippageTolerancePercentageDecimal: '0.04357',
+        };
+        const assertGetEvmChainAdapter = (_chainId) => mockEvmChainAdapter;
+        const assertGetUtxoChainAdapter = (_chainId) => {
+            throw Error('not implemented');
+        };
+        const assertGetCosmosSdkChainAdapter = (_chainId) => {
+            throw Error('not implemented');
+        };
+        const maybeTradeQuote = await getTradeQuote(input, {
+            assertGetEvmChainAdapter,
+            assertGetUtxoChainAdapter,
+            assertGetCosmosSdkChainAdapter,
+            config: {
+                VITE_FEATURE_THORCHAINSWAP_LONGTAIL: true,
+                VITE_FEATURE_THORCHAINSWAP_L1_TO_LONGTAIL: true,
+                VITE_THORCHAIN_NODE_URL: '',
+            },
+        });
+        expect(maybeTradeQuote.isOk()).toBe(true);
+        const result = maybeTradeQuote.unwrap();
+        // ids are uuids, so don't bother checking them
+        const resultWithoutIds = result.map(route => omit(route, 'id'));
+        expect(resultWithoutIds).toEqual(expectedQuoteResponse);
+    });
+});

package/dist/esm/swappers/ThorchainSwapper/getTradeRate/getTradeRate.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 } from '../../../types.js';
+export declare const getTradeRate: (input: GetTradeRateInput, deps: SwapperDeps) => Promise<Result<ThorTradeRate[], SwapErrorRight>>;

package/dist/esm/swappers/ThorchainSwapper/getTradeRate/getTradeRate.js

@@ -0,0 +1,61 @@
+import { assertUnreachable } from '@shapeshiftoss/utils';
+import { Err } from '@sniptt/monads';
+import { getL1RateOrQuote, getPoolDetails, TradeType } from '../../../thorchain-utils/index.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils.js';
+import { THORCHAIN_SUPPORTED_CHAIN_IDS } from '../constants.js';
+import { getL1ToLongtailRate } from '../utils/getL1ToLongtailRate.js';
+import { getLongtailToL1Rate } from '../utils/getLongtailRate.js';
+import { getTradeType } from '../utils/longTailHelpers.js';
+export const getTradeRate = async (input, deps) => {
+    const thorchainSwapLongtailEnabled = deps.config.VITE_FEATURE_THORCHAINSWAP_LONGTAIL;
+    const thorchainSwapL1ToLongtailEnabled = deps.config.VITE_FEATURE_THORCHAINSWAP_L1_TO_LONGTAIL;
+    const { sellAsset, buyAsset } = input;
+    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 = thorchainSwapLongtailEnabled
+        ? 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,
+        }));
+    }
+    switch (tradeType) {
+        case TradeType.L1ToL1:
+            return getL1RateOrQuote(input, deps, streamingInterval, tradeType, SwapperName.Thorchain);
+        case TradeType.LongTailToL1:
+            return getLongtailToL1Rate(input, deps, streamingInterval, SwapperName.Thorchain);
+        case TradeType.L1ToLongTail:
+            if (!thorchainSwapL1ToLongtailEnabled) {
+                return Err(makeSwapErrorRight({ message: 'Not implemented yet' }));
+            }
+            return getL1ToLongtailRate(input, deps, streamingInterval, SwapperName.Thorchain);
+        case TradeType.LongTailToLongTail:
+            return Err(makeSwapErrorRight({ message: 'Not implemented yet' }));
+        default:
+            return assertUnreachable(tradeType);
+    }
+};

package/dist/esm/swappers/ThorchainSwapper/index.d.ts

@@ -0,0 +1,7 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+export * from './constants.js';
+export * from './utils/poolAssetHelpers/poolAssetHelpers.js';
+export * from './utils/longTailHelpers.js';
+export declare const isRune: (assetId: AssetId) => boolean;
+export declare const isTcy: (assetId: AssetId) => boolean;
+export declare const isRuji: (assetId: AssetId) => boolean;

package/dist/esm/swappers/ThorchainSwapper/index.js

@@ -0,0 +1,7 @@
+import { rujiAssetId, tcyAssetId, thorchainAssetId } from '@shapeshiftoss/caip';
+export * from './constants.js';
+export * from './utils/poolAssetHelpers/poolAssetHelpers.js';
+export * from './utils/longTailHelpers.js';
+export const isRune = (assetId) => assetId === thorchainAssetId;
+export const isTcy = (assetId) => assetId === tcyAssetId;
+export const isRuji = (assetId) => assetId === rujiAssetId;

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

@@ -0,0 +1,14 @@
+import type { AssetId, ChainId } from '@shapeshiftoss/caip';
+import BigNumber from 'bignumber.js';
+import type { Address } from 'viem';
+export declare const getMaxBytesLengthByChainId: (chainId: ChainId) => number;
+export declare const addL1ToLongtailPartsToMemo: ({ sellAssetChainId, quotedMemo, aggregator, finalAssetAssetId, finalAssetAmountOut, slippageBps, longtailTokens, affiliate: _affiliate, }: {
+    sellAssetChainId: ChainId;
+    slippageBps: BigNumber.Value;
+    quotedMemo: string;
+    aggregator: Address;
+    finalAssetAssetId: AssetId;
+    finalAssetAmountOut: string;
+    longtailTokens: AssetId[];
+    affiliate: string;
+}) => string;

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

@@ -0,0 +1,64 @@
+import { bchChainId } from '@shapeshiftoss/caip';
+import { bn } from '@shapeshiftoss/chain-adapters';
+import { isUtxoChainId, subtractBasisPointAmount } from '@shapeshiftoss/utils';
+import assert from 'assert';
+import BigNumber from 'bignumber.js';
+import { addAggregatorAddressToMemo, addFinalAssetAddressToMemo, addFinalAssetLimitToMemo, assertAndProcessMemo, MEMO_PART_DELIMITER, } from '../../../../thorchain-utils/index.js';
+import { getShortenedFinalAssetLimit } from '../getShortenedFinalAssetLimit/getShortenedFinalAssetLimit.js';
+import { getUniqueAddressSubstring } from '../getUniqueAddressSubstring/getUniqueAddressSubstring.js';
+import { shortenedNativeAssetNameByNativeAssetName } from '../longTailHelpers.js';
+const BTC_MAXIMUM_BYTES_LENGTH = 80;
+const BCH_MAXIMUM_BYTES_LENGTH = 220;
+export const getMaxBytesLengthByChainId = (chainId) => {
+    if (chainId === bchChainId)
+        return BCH_MAXIMUM_BYTES_LENGTH;
+    if (isUtxoChainId(chainId))
+        return BTC_MAXIMUM_BYTES_LENGTH;
+    return Infinity;
+};
+export const addL1ToLongtailPartsToMemo = ({ sellAssetChainId, quotedMemo, aggregator, finalAssetAssetId, finalAssetAmountOut, slippageBps, longtailTokens, affiliate: _affiliate, }) => {
+    if (!quotedMemo)
+        throw new Error('no memo provided');
+    const maxMemoSize = getMaxBytesLengthByChainId(sellAssetChainId);
+    // Paranonia - If memo without final asset amount out and aggregator is already too long, we can't do anything
+    assert(quotedMemo.length <= maxMemoSize, 'memo is too long');
+    // THORChain themselves use 2 characters but it might collide at some point in the future (https://gitlab.com/thorchain/thornode/-/blob/develop/x/thorchain/aggregators/dex_mainnet_current.go)
+    const shortenedAggregatorAddress = aggregator.slice(aggregator.length - 2, aggregator.length);
+    const quotedMemoWithAggregator = addAggregatorAddressToMemo({
+        memo: quotedMemo,
+        aggregatorAddress: shortenedAggregatorAddress,
+    });
+    const finalAssetContractAddressShortened = getUniqueAddressSubstring(finalAssetAssetId, longtailTokens);
+    const quotedMemoWithAggregatorAndFinalAssetContract = addFinalAssetAddressToMemo({
+        memo: quotedMemoWithAggregator,
+        finalAssetAddress: finalAssetContractAddressShortened,
+    });
+    const [prefix, nativeAssetName, address, nativeAssetLimitWithManualSlippage, affiliate, affiliateBps, aggregatorLastTwoChars, finalAssetContract,] = quotedMemoWithAggregatorAndFinalAssetContract.split(MEMO_PART_DELIMITER);
+    const shortenedNativeAssetName = shortenedNativeAssetNameByNativeAssetName[nativeAssetName];
+    assert(shortenedNativeAssetName, 'cannot find shortened native asset name');
+    const memoWithoutFinalAssetLimit = [
+        prefix,
+        shortenedNativeAssetName,
+        address,
+        nativeAssetLimitWithManualSlippage,
+        affiliate,
+        affiliateBps,
+        aggregatorLastTwoChars,
+        finalAssetContract,
+    ].join(MEMO_PART_DELIMITER);
+    // Paranonia - If memo without final asset amount out is already too long, we can't do anything
+    assert(memoWithoutFinalAssetLimit.length <= maxMemoSize, 'memo is too long');
+    const finalAssetLimitWithManualSlippage = subtractBasisPointAmount(bn(finalAssetAmountOut).toFixed(0, BigNumber.ROUND_DOWN), slippageBps, BigNumber.ROUND_DOWN);
+    const shortenedFinalAssetAmount = getShortenedFinalAssetLimit({
+        maxMemoSize,
+        memoWithoutFinalAssetLimit,
+        finalAssetLimitWithManualSlippage,
+    });
+    const memoWithShortenedFinalAssetAmountOut = addFinalAssetLimitToMemo({
+        memo: memoWithoutFinalAssetLimit,
+        finalAssetLimit: shortenedFinalAssetAmount,
+        affiliate: _affiliate,
+    });
+    assert(memoWithShortenedFinalAssetAmountOut.length <= maxMemoSize, 'memo is too long');
+    return assertAndProcessMemo(memoWithShortenedFinalAssetAmountOut, _affiliate);
+};

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

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

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

@@ -0,0 +1,116 @@
+import { btcChainId, dogeChainId, ethChainId, toAssetId } from '@shapeshiftoss/caip';
+import { describe, expect, it } from 'vitest';
+import { THORCHAIN_AFFILIATE_NAME } from '../../constants.js';
+import { addL1ToLongtailPartsToMemo, getMaxBytesLengthByChainId, } from './addL1ToLongtailPartsToMemo.js';
+const AGGREGATOR_ADDRESS = '0xd31f7e39afECEc4855fecc51b693F9A0Cec49fd2';
+const BIG_ADDRESS = '0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb632DBc9Cf9E8FbCebE1e';
+const REALLY_BIG_ADDRESS = '0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb632DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb632DBc9Cf9E8Fb1bE1e0a2ecF05Ed86Ca3096Cb632DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb632DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6';
+const COLLIDING_FINAL_ASSETID = toAssetId({
+    chainId: ethChainId,
+    assetReference: '0xa0b86991c6218b36c1d19d4a2e9eb0ce36dF4741',
+    assetNamespace: 'erc20',
+});
+const FINAL_ASSET_ASSETID = toAssetId({
+    chainId: ethChainId,
+    assetReference: '0x8a65ac0E23F31979db06Ec62Af62b432a6dF4741',
+    assetNamespace: 'erc20',
+});
+const THORCHAIN_ASSETIDS_ONE_COLLISION = [FINAL_ASSET_ASSETID, COLLIDING_FINAL_ASSETID];
+const slippageBps = 100; // 1%
+describe('addL1ToLongtailPartsToMemo', () => {
+    it('should add aggregator address, shortened destination address and finalAssetAmountOut correctly', () => {
+        const finalAssetAmountOut = '9508759019';
+        const quotedMemo = `=:ETH.ETH:0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6:42:ss:100`;
+        const modifiedMemo = addL1ToLongtailPartsToMemo({
+            sellAssetChainId: ethChainId,
+            quotedMemo,
+            aggregator: AGGREGATOR_ADDRESS,
+            finalAssetAssetId: FINAL_ASSET_ASSETID,
+            finalAssetAmountOut,
+            slippageBps,
+            longtailTokens: THORCHAIN_ASSETIDS_ONE_COLLISION,
+            affiliate: THORCHAIN_AFFILIATE_NAME,
+        });
+        expect(modifiedMemo).toBe(
+        // The aggregator will turn the finalAssetAmountOut from 94136714201 to 9413671420 using the last 2 bytes as exponents
+        `=:e:0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6:42:ss:100:d2:a6df4741:94136714201`);
+    });
+    it('should throw if chainId is BCH and initial memo length is > 220', () => {
+        const finalAssetAmountOut = '2083854765519275828179229';
+        const memoOver220Bytes = `=:ETH.ETH:${REALLY_BIG_ADDRESS}:42:ss:100`;
+        expect(memoOver220Bytes.length).toBe(221);
+        expect(() => addL1ToLongtailPartsToMemo({
+            sellAssetChainId: dogeChainId,
+            quotedMemo: memoOver220Bytes,
+            aggregator: AGGREGATOR_ADDRESS,
+            finalAssetAssetId: FINAL_ASSET_ASSETID,
+            finalAssetAmountOut,
+            slippageBps,
+            longtailTokens: THORCHAIN_ASSETIDS_ONE_COLLISION,
+            affiliate: THORCHAIN_AFFILIATE_NAME,
+        })).toThrow('memo is too long');
+    });
+    it('should throw if chainId is BTC and initial memo length is > 80', () => {
+        const finalAssetAmountOut = '2083854765519275828179229';
+        const memoOver80Bytes = `=:ETH.ETH:${BIG_ADDRESS}:42:ss:100`;
+        expect(memoOver80Bytes.length).toBe(81);
+        expect(() => addL1ToLongtailPartsToMemo({
+            sellAssetChainId: btcChainId,
+            quotedMemo: memoOver80Bytes,
+            aggregator: AGGREGATOR_ADDRESS,
+            finalAssetAssetId: FINAL_ASSET_ASSETID,
+            finalAssetAmountOut,
+            slippageBps,
+            longtailTokens: THORCHAIN_ASSETIDS_ONE_COLLISION,
+            affiliate: THORCHAIN_AFFILIATE_NAME,
+        })).toThrow('memo is too long');
+    });
+    it('should throw if chainId is DOGE and initial memo length is > 80', () => {
+        const finalAssetAmountOut = '2083854765519275828179229';
+        const memoOver80Bytes = `=:ETH.ETH:${BIG_ADDRESS}:42:ss:100`;
+        expect(memoOver80Bytes.length).toBe(81);
+        expect(() => addL1ToLongtailPartsToMemo({
+            sellAssetChainId: dogeChainId,
+            quotedMemo: memoOver80Bytes,
+            aggregator: AGGREGATOR_ADDRESS,
+            finalAssetAssetId: FINAL_ASSET_ASSETID,
+            finalAssetAmountOut,
+            slippageBps,
+            longtailTokens: THORCHAIN_ASSETIDS_ONE_COLLISION,
+            affiliate: THORCHAIN_AFFILIATE_NAME,
+        })).toThrow('memo is too long');
+    });
+    it('should throw if chainId is DOGE and initial memo length is under 80 but aggregator addition is making it over 80', () => {
+        const finalAssetAmountOut = '2083854765519275828179229';
+        const memoOver80Bytes = `=:ETH.ETH:${BIG_ADDRESS}:42:ss:1`;
+        expect(memoOver80Bytes.length).toBe(79);
+        expect(() => addL1ToLongtailPartsToMemo({
+            sellAssetChainId: dogeChainId,
+            quotedMemo: memoOver80Bytes,
+            aggregator: AGGREGATOR_ADDRESS,
+            finalAssetAssetId: FINAL_ASSET_ASSETID,
+            finalAssetAmountOut,
+            slippageBps,
+            longtailTokens: THORCHAIN_ASSETIDS_ONE_COLLISION,
+            affiliate: THORCHAIN_AFFILIATE_NAME,
+        })).toThrow('memo is too long');
+    });
+    it('should be successful if chainId is DOGE and memo length is < 80', () => {
+        const finalAssetAmountOut = '2083854765519275828179229';
+        const quotedMemo = `=:ETH.ETH:0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6:42:ss:100`;
+        const modifiedMemo = addL1ToLongtailPartsToMemo({
+            sellAssetChainId: dogeChainId,
+            quotedMemo,
+            aggregator: AGGREGATOR_ADDRESS,
+            finalAssetAssetId: FINAL_ASSET_ASSETID,
+            finalAssetAmountOut,
+            slippageBps,
+            longtailTokens: THORCHAIN_ASSETIDS_ONE_COLLISION,
+            affiliate: THORCHAIN_AFFILIATE_NAME,
+        });
+        expect(modifiedMemo.length).toBeLessThanOrEqual(getMaxBytesLengthByChainId(dogeChainId));
+        expect(modifiedMemo).toBe(
+        // The aggregator will turn the finalAssetAmountOut from 20630162116 to 2063016210000000000000000 using the last 2 bytes as exponents
+        `=:e:0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6:42:ss:100:d2:a6df4741:20630162116`);
+    });
+});

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

@@ -0,0 +1,4 @@
+import { Token } from '@uniswap/sdk-core';
+export declare const WETH_TOKEN: Token;
+export declare const WAVAX_TOKEN: Token;
+export declare const WBNB_TOKEN: Token;

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

@@ -0,0 +1,5 @@
+import { CHAIN_REFERENCE } from '@shapeshiftoss/caip';
+import { Token } from '@uniswap/sdk-core';
+export const WETH_TOKEN = new Token(Number(CHAIN_REFERENCE.EthereumMainnet), '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', 18, 'WETH', 'Wrapped Ether');
+export const WAVAX_TOKEN = new Token(Number(CHAIN_REFERENCE.AvalancheCChain), '0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7', 18, 'WAVAX', 'Wrapped AVAX');
+export const WBNB_TOKEN = new Token(Number(CHAIN_REFERENCE.BnbSmartChainMainnet), '0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c', 18, 'WBNB', 'Wrapped BNB');

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

@@ -0,0 +1,6 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { Token } from '@uniswap/sdk-core';
+export declare const getBestAggregator: (buyAsset: Asset, sellToken: Token, buyToken: Token, sellAmountIncludingProtocolFeesCryptoBaseUnit: string) => Promise<import("@sniptt/monads/build/result/result").ResErr<unknown, import("../../../types.js").SwapErrorRight> | import("@sniptt/monads/build/result/result").ResOk<{
+    bestAggregator: import("./longTailHelpers.js").AggregatorContract;
+    quotedAmountOut: bigint;
+}, never>>;