@shapeshiftoss/swapper 17.7.3 → 18.1.0

package/dist/esm/swappers/SunioSwapper/utils/getSunioTradeContext.js

@@ -0,0 +1,93 @@
+import { BigAmount, bn } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils/index.js';
+import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
+import { DEFAULT_SLIPPAGE_PERCENTAGE, SUNIO_SMART_ROUTER_CONTRACT } from './constants.js';
+import { fetchSunioQuote } from './fetchFromSunio.js';
+import { assertValidTrade } from './helpers.js';
+import { sunioServiceFactory } from './sunioService.js';
+export const getSunioTradeContext = async ({ input, deps, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps, slippageTolerancePercentageDecimal, } = input;
+    const assertion = assertValidTrade({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    try {
+        const maybeQuoteResponse = await fetchSunioQuote({
+            sellAssetId: sellAsset.assetId,
+            buyAssetId: buyAsset.assetId,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        }, sunioServiceFactory());
+        if (maybeQuoteResponse.isErr())
+            return Err(maybeQuoteResponse.unwrapErr());
+        const bestRoute = maybeQuoteResponse.unwrap().data[0];
+        if (!bestRoute) {
+            return Err(makeSwapErrorRight({
+                message: '[Sun.io] No routes available',
+                code: TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const buyAmountCryptoBaseUnit = BigAmount.fromPrecision({
+            value: bestRoute.amountOut,
+            precision: buyAsset.precision,
+        }).toBaseUnit();
+        const rate = getInputOutputRate({
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const protocolFeeCryptoBaseUnit = bn(bestRoute.fee)
+            .times(sellAmountIncludingProtocolFeesCryptoBaseUnit)
+            .toFixed(0);
+        const protocolFees = (() => {
+            if (bn(protocolFeeCryptoBaseUnit).lte(0))
+                return;
+            return {
+                [sellAsset.assetId]: {
+                    amountCryptoBaseUnit: protocolFeeCryptoBaseUnit,
+                    requiresBalance: false,
+                    asset: sellAsset,
+                },
+            };
+        })();
+        return Ok({
+            tradeCommon: {
+                id: crypto.randomUUID(),
+                rate,
+                affiliateBps,
+                slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ?? DEFAULT_SLIPPAGE_PERCENTAGE,
+                swapperName: SwapperName.Sunio,
+            },
+            stepCommon: {
+                buyAmountBeforeFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
+                buyAmountAfterFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                rate,
+                source: SwapperName.Sunio,
+                buyAsset,
+                sellAsset,
+                allowanceContract: SUNIO_SMART_ROUTER_CONTRACT,
+                estimatedExecutionTimeMs: undefined,
+                affiliateFee: buildAffiliateFee({
+                    strategy: 'buy_asset',
+                    affiliateBps,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    buyAmountCryptoBaseUnit,
+                    isEstimate: true,
+                }),
+            },
+            protocolFees,
+            stepDataArgs: { deps, sellAsset, route: bestRoute },
+        });
+    }
+    catch (error) {
+        return Err(makeSwapErrorRight({
+            message: '[Sun.io] Failed to get trade',
+            code: TradeQuoteError.UnknownError,
+            cause: error,
+        }));
+    }
+};

package/dist/esm/swappers/SunioSwapper/utils/getSunioTransactionFees.d.ts

@@ -0,0 +1,2 @@
+import type { GetUnsignedTronTransactionArgs } from '../../../types.js';
+export declare const getSunioTransactionFees: ({ tradeQuote, stepIndex, from, slippageTolerancePercentageDecimal, assertGetTronChainAdapter, config, }: GetUnsignedTronTransactionArgs) => Promise<string>;

package/dist/esm/swappers/SunioSwapper/utils/getSunioTransactionFees.js

@@ -0,0 +1,32 @@
+import { tronAssetId, tronChainId } from '@shapeshiftoss/caip';
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../../../utils/index.js';
+import { estimateSunioNetworkFeeCryptoBaseUnit } from './estimateSunioNetworkFee.js';
+export const getSunioTransactionFees = async ({ tradeQuote, stepIndex, from, slippageTolerancePercentageDecimal, assertGetTronChainAdapter, config, }) => {
+    if (!isExecutableTradeQuote(tradeQuote))
+        throw new Error('Unable to execute a trade rate quote');
+    const step = getExecutableTradeStep(tradeQuote, stepIndex);
+    const storedNetworkFeeCryptoBaseUnit = step.feeData.networkFeeCryptoBaseUnit;
+    const route = step.sunioTransactionData?.route;
+    if (!route) {
+        if (!storedNetworkFeeCryptoBaseUnit)
+            throw new Error('Missing network fee in quote');
+        return storedNetworkFeeCryptoBaseUnit;
+    }
+    try {
+        const adapter = assertGetTronChainAdapter(tronChainId);
+        return await estimateSunioNetworkFeeCryptoBaseUnit({
+            rpcUrl: adapter.httpProvider.getRpcUrl(),
+            apiKey: config.VITE_TRON_GRID_API_KEY,
+            route,
+            sellAmountCryptoBaseUnit: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            isSellingNativeTrx: step.sellAsset.assetId === tronAssetId,
+            address: from,
+            slippageTolerancePercentageDecimal,
+        });
+    }
+    catch {
+        if (!storedNetworkFeeCryptoBaseUnit)
+            throw new Error('Missing network fee in quote');
+        return storedNetworkFeeCryptoBaseUnit;
+    }
+};

package/dist/esm/swappers/SunioSwapper/utils/helpers.d.ts

@@ -0,0 +1,10 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types.js';
+export declare const isSupportedChainId: (chainId: string) => boolean;
+export declare const assetIdToTronToken: (assetId: AssetId) => string;
+export declare const assertValidTrade: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Result<void, SwapErrorRight>;

package/dist/esm/swappers/SunioSwapper/utils/helpers.js

@@ -0,0 +1,38 @@
+import { fromAssetId, tronChainId } from '@shapeshiftoss/caip';
+import { isToken } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
+import { SUNIO_SUPPORTED_CHAIN_IDS, SUNIO_TRON_NATIVE_ADDRESS } from './constants.js';
+export const isSupportedChainId = (chainId) => {
+    return SUNIO_SUPPORTED_CHAIN_IDS.includes(chainId);
+};
+export const assetIdToTronToken = (assetId) => {
+    if (isToken(assetId)) {
+        const { assetReference } = fromAssetId(assetId);
+        return assetReference;
+    }
+    return SUNIO_TRON_NATIVE_ADDRESS;
+};
+export const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    if (!isSupportedChainId(sellAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `[${SwapperName.Sunio}] Unsupported chainId: ${sellAsset.chainId}`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (sellAsset.chainId !== buyAsset.chainId) {
+        return Err(makeSwapErrorRight({
+            message: `[${SwapperName.Sunio}] Cross-chain not supported`,
+            code: TradeQuoteError.CrossChainNotSupported,
+        }));
+    }
+    if (sellAsset.chainId !== tronChainId) {
+        return Err(makeSwapErrorRight({
+            message: `[${SwapperName.Sunio}] Only TRON chain supported`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    return Ok(undefined);
+};

package/dist/esm/swappers/SunioSwapper/utils/sunioService.js

@@ -1,4 +1,4 @@
-import { createCache, makeSwapperAxiosServiceMonadic } from '../../../utils.js';
+import { createCache, makeSwapperAxiosServiceMonadic } from '../../../utils/index.js';
 const maxAge = 5 * 1000;
 const cachedUrls = ['/swap/router'];
 export const sunioServiceFactory = () => {

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

@@ -1,4 +1,4 @@
-import { executeEvmTransaction } from '../../utils.js';
+import { executeEvmTransaction } from '../../utils/index.js';
 export const thorchainSwapper = {
     executeEvmTransaction,
     executeCosmosSdkTransaction: (txToSign, { signAndBroadcastTransaction }) => {

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

@@ -1,78 +1,25 @@
-import { cosmosAssetId, rujiAssetId, tcyAssetId, thorchainAssetId } from '@shapeshiftoss/caip';
-import { checkTradeStatus, cosmossdk, evm, getInboundAddressDataForChain, solana, tron, utxo, } from '../../thorchain-utils/index.js';
 import { SwapperName } from '../../types.js';
-import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { getCosmosSdkTransactionFees, getUnsignedCosmosSdkTransaction } from '../../utils/cosmossdk/index.js';
+import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
+import { getSolanaTransactionFees, getUnsignedSolanaTransaction } from '../../utils/solana/index.js';
+import { checkTradeStatus, tron } from '../../utils/thorchain/index.js';
+import { getUnsignedUtxoTransaction, getUtxoTransactionFees } from '../../utils/utxo/index.js';
 import { getTradeQuote } from './getTradeQuote/getTradeQuote.js';
 import { getTradeRate } from './getTradeRate/getTradeRate.js';
 const swapperName = SwapperName.Thorchain;
 export const thorchainApi = {
-    getTradeRate,
-    getTradeQuote,
-    getUnsignedEvmTransaction: input => evm.getUnsignedEvmTransaction(input, swapperName),
-    getEvmTransactionFees: input => evm.getEvmTransactionFees(input, swapperName),
-    getUnsignedUtxoTransaction: input => utxo.getUnsignedUtxoTransaction(input, swapperName),
-    getUtxoTransactionFees: input => utxo.getUtxoTransactionFees(input, swapperName),
-    getUnsignedSolanaTransaction: input => solana.getUnsignedSolanaTransaction(input, swapperName),
-    getSolanaTransactionFees: input => solana.getSolanaTransactionFees(input, swapperName),
+    getTradeRate: (input, deps) => getTradeRate(input, deps),
+    getTradeQuote: (input, deps) => getTradeQuote(input, deps),
+    getUnsignedEvmTransaction,
+    getEvmTransactionFees,
+    getUnsignedUtxoTransaction,
+    getUtxoTransactionFees,
+    getUnsignedCosmosSdkTransaction,
+    getCosmosSdkTransactionFees,
+    getUnsignedSolanaTransaction,
+    getSolanaTransactionFees,
     getUnsignedTronTransaction: input => tron.getUnsignedTronTransaction(input, swapperName),
     getTronTransactionFees: input => tron.getTronTransactionFees(input, swapperName),
-    getUnsignedCosmosSdkTransaction: async ({ tradeQuote, stepIndex, from, config, assertGetCosmosSdkChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const { memo } = tradeQuote;
-        if (!memo)
-            throw new Error('Memo is required');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { accountNumber, sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset, feeData } = step;
-        const gas = feeData.chainSpecific.estimatedGasCryptoBaseUnit;
-        const fee = feeData.networkFeeCryptoBaseUnit ?? '0';
-        switch (sellAsset.assetId) {
-            case thorchainAssetId:
-            case rujiAssetId:
-            case tcyAssetId: {
-                const coin = (() => {
-                    if (sellAsset.assetId === tcyAssetId)
-                        return 'THOR.TCY';
-                    if (sellAsset.assetId === rujiAssetId)
-                        return 'THOR.RUJI';
-                    return 'THOR.RUNE';
-                })();
-                const adapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
-                const { txToSign } = await adapter.buildDepositTransaction({
-                    accountNumber,
-                    from,
-                    value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                    memo,
-                    chainSpecific: {
-                        gas,
-                        fee,
-                        coin,
-                    },
-                });
-                return txToSign;
-            }
-            case cosmosAssetId: {
-                const adapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
-                const url = `${config.VITE_THORCHAIN_NODE_URL}/thorchain`;
-                const data = await getInboundAddressDataForChain(url, cosmosAssetId, true, swapperName);
-                if (data.isErr())
-                    throw data.unwrapErr();
-                const { address: vault } = data.unwrap();
-                const { txToSign } = await adapter.buildSendApiTransaction({
-                    accountNumber,
-                    from,
-                    to: vault,
-                    value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                    memo,
-                    chainSpecific: { gas, fee },
-                });
-                return txToSign;
-            }
-            default:
-                throw Error(`Unsupported sellAsset: ${sellAsset.assetId}`);
-        }
-    },
-    getCosmosSdkTransactionFees: input => cosmossdk.getCosmosSdkTransactionFees(input),
     checkTradeStatus: input => {
         const { config } = input;
         const nodeUrl = `${config.VITE_THORCHAIN_NODE_URL}/thorchain`;

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

@@ -1015,6 +1015,7 @@
     "eip155:1/erc20:0x815c23eca83261b6ec689b60cc4a58b54bc24d8d",
     "eip155:1/erc20:0x826180541412d574cf1336d22c0c0a287822678a",
     "eip155:1/erc20:0x2c06ba9e7f0daccbc1f6a33ea67e85bb68fbee3a",
+    "eip155:1/erc20:0xcbb8f1bda10b9696c57e13bc128fe674769dcec0",
     "eip155:43114/erc20:0xc891eb4cbdeff6e073e859e987815ed1505c2acd",
     "eip155:43114/erc20:0xd24c2ad096400b6fbcd2ad8b24e7acbc21a1da64",
     "eip155:43114/erc20:0x47c3118ad183712acd42648e9e522e13690f29a0",

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

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

@@ -1,55 +1,24 @@
 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 { SwapperName } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
+import { getThorL1TradeQuote, TradeType } from '../../../utils/thorchain/index.js';
+import { assertValidTrade } from '../utils/assertValidTrade.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,
-        }));
-    }
+    const assertion = await assertValidTrade({ sellAsset, buyAsset, deps });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const { tradeType, streamingInterval } = assertion.unwrap();
     switch (tradeType) {
         case TradeType.L1ToL1:
-            return getL1RateOrQuote(input, deps, streamingInterval, tradeType, SwapperName.Thorchain);
+            return getThorL1TradeQuote(input, deps, streamingInterval, tradeType, SwapperName.Thorchain);
         case TradeType.LongTailToL1:
             return getLongtailToL1Quote(input, deps, streamingInterval, SwapperName.Thorchain);
         case TradeType.L1ToLongTail:
-            if (!thorchainSwapL1ToLongtailEnabled) {
+            if (!deps.config.VITE_FEATURE_THORCHAINSWAP_L1_TO_LONGTAIL) {
                 return Err(makeSwapErrorRight({ message: 'Not implemented yet' }));
             }
             return getL1ToLongtailQuote(input, deps, streamingInterval, SwapperName.Thorchain);

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

@@ -1,21 +1,29 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
 import { Ok } from '@sniptt/monads';
 import { omit } from 'lodash';
+import { getAddress } from 'viem';
 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 { ETH, FOX_MAINNET } from '../../../utils/test-data/assets.js';
+import { setupQuote } from '../../../utils/test-data/setupSwapQuote.js';
+import { depositWithExpiry, getThorRouterAndVault, thorService, TradeType, } from '../../../utils/thorchain/index.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 mockedGetThorRouterAndVault = vi.mocked(getThorRouterAndVault);
 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', () => {
+vi.mock('../../../utils/thorchain/getThorTxData');
+// The override path reads live chain state - resolve to no override so estimation exercises the
+// mocked adapter
+vi.mock('../../../utils/evm/stateOverride', async (importOriginal) => ({
+    ...(await importOriginal()),
+    getMinimalStateOverride: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock('../../../utils/thorchain/service', () => {
     const mockAxios = {
         default: {
             create: vi.fn(() => ({
@@ -28,12 +36,18 @@ vi.mock('../../../thorchain-utils/service', () => {
         thorService: mockAxios.default.create(),
     };
 });
-vi.mock('@/config', () => {
-    return {
-        getConfig: () => ({
-            VITE_THORCHAIN_NODE_URL: '',
-        }),
-    };
+const THOR_VAULT = '0x06828ac8dbf4cc9e5f363ead14629c9b330c0f5c';
+const SELL_AMOUNT = '713014679420';
+const EXPIRY = 1713710808;
+const REGULAR_MEMO = '=:ETH.ETH:0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6:9786345:ss:0';
+const STREAMING_MEMO = '=:ETH.ETH:0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6:0/10/0:ss:0';
+// The deposit calldata is asserted as the encoding of the memo it sits alongside
+const expectedDepositData = (memo) => depositWithExpiry({
+    vault: THOR_VAULT,
+    asset: getAddress(fromAssetId(FOX_MAINNET.assetId).assetReference),
+    amount: BigInt(SELL_AMOUNT),
+    memo,
+    expiry: BigInt(EXPIRY),
 });
 const expectedQuoteResponse = [
     {
@@ -43,10 +57,8 @@ const expectedQuoteResponse = [
         isStreaming: false,
         recommendedMinimumCryptoBaseUnit: '10000000000',
         rate: '143505.61489594191334131621',
-        data: '0x',
-        router: '0x3624525075b88B24ecc29CE226b0CEc1fFcB6976',
-        vault: '0x06828ac8dbf4cc9e5f363ead14629c9b330c0f5c',
-        memo: '=:ETH.ETH:0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6:9786345:ss:0',
+        data: expectedDepositData(REGULAR_MEMO),
+        memo: REGULAR_MEMO,
         tradeType: TradeType.L1ToL1,
         slippageTolerancePercentageDecimal: '0.04357',
         expiry: 1713710808,
@@ -73,13 +85,17 @@ const expectedQuoteResponse = [
                 buyAsset: ETH,
                 sellAsset: FOX_MAINNET,
                 accountNumber: 0,
-                thorchainSpecific: {
+                swapperMetadata: {
+                    name: 'thorchain',
                     maxStreamingQuantity: undefined,
                 },
-                thorchainTransactionMetadata: {
+                transactionData: {
+                    type: 'evm',
+                    chainId: 1,
                     to: '0x3624525075b88B24ecc29CE226b0CEc1fFcB6976',
-                    data: '0x',
+                    data: expectedDepositData(REGULAR_MEMO),
                     value: '0',
+                    gasLimit: '120000',
                 },
             },
         ],
@@ -91,10 +107,8 @@ const expectedQuoteResponse = [
         isStreaming: true,
         recommendedMinimumCryptoBaseUnit: '10000000000',
         rate: '157530.57158846677816130059',
-        data: '0x',
-        router: '0x3624525075b88B24ecc29CE226b0CEc1fFcB6976',
-        vault: '0x06828ac8dbf4cc9e5f363ead14629c9b330c0f5c',
-        memo: '=:ETH.ETH:0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6:0/10/0:ss:0',
+        data: expectedDepositData(STREAMING_MEMO),
+        memo: STREAMING_MEMO,
         tradeType: TradeType.L1ToL1,
         slippageTolerancePercentageDecimal: undefined,
         expiry: 1713710808,
@@ -121,21 +135,24 @@ const expectedQuoteResponse = [
                 buyAsset: ETH,
                 sellAsset: FOX_MAINNET,
                 accountNumber: 0,
-                thorchainSpecific: {
+                swapperMetadata: {
+                    name: 'thorchain',
                     maxStreamingQuantity: undefined,
                 },
-                thorchainTransactionMetadata: {
+                transactionData: {
+                    type: 'evm',
+                    chainId: 1,
                     to: '0x3624525075b88B24ecc29CE226b0CEc1fFcB6976',
-                    data: '0x',
+                    data: expectedDepositData(STREAMING_MEMO),
                     value: '0',
+                    gasLimit: '120000',
                 },
             },
         ],
     },
 ];
 describe('getTradeQuote', () => {
-    mockedGetThorTxInfo.mockReturnValue(Promise.resolve({
-        data: '0x',
+    mockedGetThorRouterAndVault.mockReturnValue(Promise.resolve({
         router: '0x3624525075b88B24ecc29CE226b0CEc1fFcB6976',
         vault: '0x06828ac8dbf4cc9e5f363ead14629c9b330c0f5c',
     }));
@@ -190,6 +207,7 @@ describe('getTradeQuote', () => {
             sellAmountIncludingProtocolFeesCryptoBaseUnit: '713014679420',
             buyAsset: ETH,
             sellAsset: FOX_MAINNET,
+            sendAddress: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
             slippageTolerancePercentageDecimal: '0.04357',
         };
         const assertGetEvmChainAdapter = (_chainId) => mockEvmChainAdapter;

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

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

@@ -1,55 +1,24 @@
 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 { SwapperName } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
+import { getThorL1TradeRate, TradeType } from '../../../utils/thorchain/index.js';
+import { assertValidTrade } from '../utils/assertValidTrade.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,
-        }));
-    }
+    const assertion = await assertValidTrade({ sellAsset, buyAsset, deps });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const { tradeType, streamingInterval } = assertion.unwrap();
     switch (tradeType) {
         case TradeType.L1ToL1:
-            return getL1RateOrQuote(input, deps, streamingInterval, tradeType, SwapperName.Thorchain);
+            return getThorL1TradeRate(input, deps, streamingInterval, tradeType, SwapperName.Thorchain);
         case TradeType.LongTailToL1:
             return getLongtailToL1Rate(input, deps, streamingInterval, SwapperName.Thorchain);
         case TradeType.L1ToLongTail:
-            if (!thorchainSwapL1ToLongtailEnabled) {
+            if (!deps.config.VITE_FEATURE_THORCHAINSWAP_L1_TO_LONGTAIL) {
                 return Err(makeSwapErrorRight({ message: 'Not implemented yet' }));
             }
             return getL1ToLongtailRate(input, deps, streamingInterval, SwapperName.Thorchain);

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

@@ -5,3 +5,5 @@ 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;
+export { thorchainApi } from './endpoints.js';
+export { thorchainSwapper } from './ThorchainSwapper.js';

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

@@ -5,3 +5,5 @@ export * from './utils/longTailHelpers.js';
 export const isRune = (assetId) => assetId === thorchainAssetId;
 export const isTcy = (assetId) => assetId === tcyAssetId;
 export const isRuji = (assetId) => assetId === rujiAssetId;
+export { thorchainApi } from './endpoints.js';
+export { thorchainSwapper } from './ThorchainSwapper.js';

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

@@ -3,7 +3,7 @@ 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 { addAggregatorAddressToMemo, addFinalAssetAddressToMemo, addFinalAssetLimitToMemo, assertAndProcessMemo, MEMO_PART_DELIMITER, } from '../../../../utils/thorchain/index.js';
 import { getShortenedFinalAssetLimit } from '../getShortenedFinalAssetLimit/getShortenedFinalAssetLimit.js';
 import { getUniqueAddressSubstring } from '../getUniqueAddressSubstring/getUniqueAddressSubstring.js';
 import { shortenedNativeAssetNameByNativeAssetName } from '../longTailHelpers.js';

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

@@ -0,0 +1,18 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight, SwapperDeps } from '../../../types.js';
+export declare const assertValidLongtailToL1Trade: ({ sellAsset, deps, }: {
+    sellAsset: Asset;
+    deps: SwapperDeps;
+}) => Result<{
+    buyAssetFeeAsset: Asset;
+}, SwapErrorRight>;
+export declare const assertValidL1ToLongtailTrade: ({ sellAsset, buyAsset, deps, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+    deps: SwapperDeps;
+}) => Promise<Result<{
+    buyAssetFeeAsset: Asset;
+    longtailTokens: AssetId[];
+}, SwapErrorRight>>;