@shapeshiftoss/swapper 17.8.0 → 19.0.0

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

@@ -1,152 +0,0 @@
-import { tronChainId } from '@shapeshiftoss/caip';
-import { BigAmount, bn, contractAddressOrUndefined } from '@shapeshiftoss/utils';
-import { Err, Ok } from '@sniptt/monads';
-import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
-import { buildAffiliateFee } from '../../utils/affiliateFee.js';
-import { DEFAULT_SLIPPAGE_PERCENTAGE, SUNIO_SMART_ROUTER_CONTRACT } from './constants.js';
-import { estimateSunioNetworkFeeCryptoBaseUnit } from './estimateSunioNetworkFee.js';
-import { fetchSunioQuote } from './fetchFromSunio.js';
-import { isSupportedChainId } from './helpers/helpers.js';
-import { sunioServiceFactory } from './sunioService.js';
-export async function getQuoteOrRate(input, deps) {
-    try {
-        const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, accountNumber, affiliateBps, slippageTolerancePercentageDecimal, } = input;
-        const { assertGetTronChainAdapter: _assertGetTronChainAdapter } = deps;
-        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,
-            }));
-        }
-        const service = sunioServiceFactory();
-        const maybeQuoteResponse = await fetchSunioQuote({
-            sellAssetId: sellAsset.assetId,
-            buyAssetId: buyAsset.assetId,
-            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-        }, service);
-        if (maybeQuoteResponse.isErr()) {
-            return Err(maybeQuoteResponse.unwrapErr());
-        }
-        const quoteResponse = maybeQuoteResponse.unwrap();
-        const bestRoute = quoteResponse.data[0];
-        if (!bestRoute) {
-            return Err(makeSwapErrorRight({
-                message: '[Sun.io] No routes available',
-                code: TradeQuoteError.NoRouteFound,
-            }));
-        }
-        const isQuote = input.quoteOrRate === 'quote';
-        // For quotes, receiveAddress is required
-        if (isQuote && !receiveAddress) {
-            return Err(makeSwapErrorRight({
-                message: '[Sun.io] receiveAddress is required for quotes',
-                code: TradeQuoteError.InternalError,
-            }));
-        }
-        const networkFeeCryptoBaseUnit = await (async () => {
-            try {
-                return await estimateSunioNetworkFeeCryptoBaseUnit({
-                    rpcUrl: deps.config.VITE_TRON_NODE_URL,
-                    apiKey: deps.config.VITE_TRON_GRID_API_KEY,
-                    route: bestRoute,
-                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                    isSellingNativeTrx: !contractAddressOrUndefined(sellAsset.assetId),
-                    address: receiveAddress,
-                    slippageTolerancePercentageDecimal,
-                });
-            }
-            catch (error) {
-                // For rates, fall back to '0' on unexpected failure; quotes require an accurate fee
-                if (!isQuote)
-                    return '0';
-                throw error;
-            }
-        })();
-        const buyAmountCryptoBaseUnit = BigAmount.fromPrecision({
-            value: bestRoute.amountOut,
-            precision: buyAsset.precision,
-        }).toBaseUnit();
-        // Calculate protocol fees only for quotes
-        const protocolFeeCryptoBaseUnit = isQuote
-            ? bn(bestRoute.fee).times(sellAmountIncludingProtocolFeesCryptoBaseUnit).toFixed(0)
-            : '0';
-        const buyAmountAfterFeesCryptoBaseUnit = buyAmountCryptoBaseUnit;
-        const rate = getInputOutputRate({
-            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            buyAmountCryptoBaseUnit,
-            sellAsset,
-            buyAsset,
-        });
-        const trade = {
-            id: crypto.randomUUID(),
-            quoteOrRate: input.quoteOrRate,
-            rate,
-            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ?? DEFAULT_SLIPPAGE_PERCENTAGE,
-            receiveAddress,
-            affiliateBps,
-            steps: [
-                {
-                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
-                    buyAmountAfterFeesCryptoBaseUnit,
-                    sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                    feeData: {
-                        networkFeeCryptoBaseUnit,
-                        protocolFees: protocolFeeCryptoBaseUnit !== '0'
-                            ? {
-                                [sellAsset.assetId]: {
-                                    amountCryptoBaseUnit: protocolFeeCryptoBaseUnit,
-                                    requiresBalance: false,
-                                    asset: sellAsset,
-                                },
-                            }
-                            : {},
-                    },
-                    rate,
-                    source: SwapperName.Sunio,
-                    buyAsset,
-                    sellAsset,
-                    accountNumber,
-                    allowanceContract: SUNIO_SMART_ROUTER_CONTRACT,
-                    estimatedExecutionTimeMs: undefined,
-                    ...(isQuote && {
-                        sunioTransactionMetadata: {
-                            route: bestRoute,
-                        },
-                    }),
-                    affiliateFee: buildAffiliateFee({
-                        strategy: 'buy_asset',
-                        affiliateBps,
-                        sellAsset,
-                        buyAsset,
-                        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-                        isEstimate: true,
-                    }),
-                },
-            ],
-            swapperName: SwapperName.Sunio,
-        };
-        return Ok(trade);
-    }
-    catch (error) {
-        return Err(makeSwapErrorRight({
-            message: `[Sun.io] Failed to get trade ${input.quoteOrRate}`,
-            code: TradeQuoteError.UnknownError,
-            cause: error,
-        }));
-    }
-}

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

@@ -1,4 +0,0 @@
-import type { AssetId } from '@shapeshiftoss/caip';
-export declare const isSupportedChainId: (chainId: string) => boolean;
-export declare const assetIdToTronToken: (assetId: AssetId) => string;
-export declare const isTronChainId: (chainId: string) => chainId is import("@shapeshiftoss/caip").ChainId;

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

@@ -1,16 +0,0 @@
-import { fromAssetId, tronChainId } from '@shapeshiftoss/caip';
-import { isToken } from '@shapeshiftoss/utils';
-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 isTronChainId = (chainId) => {
-    return chainId === tronChainId;
-};

package/dist/esm/swappers/ZrxSwapper/getZrxTradeQuote/getZrxTradeQuote.test.d.ts

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

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

@@ -1,134 +0,0 @@
-import { btcChainId } from '@shapeshiftoss/caip';
-import { KnownChainIds } from '@shapeshiftoss/types';
-import { Err, Ok } from '@sniptt/monads';
-import { describe, expect, it, vi } from 'vitest';
-import { TradeQuoteError } from '../../../types.js';
-import { BTC } from '../../utils/test-data/assets.js';
-import { gasFeeData } from '../../utils/test-data/fees.js';
-import { setupQuote } from '../../utils/test-data/setupSwapQuote.js';
-import { zrxServiceFactory } from '../utils/zrxService.js';
-import { getZrxTradeQuote } from './getZrxTradeQuote.js';
-vi.mock('../utils/zrxService', () => {
-    const get = vi.fn();
-    const post = vi.fn();
-    return {
-        zrxServiceFactory: vi.fn(() => ({
-            get,
-            post,
-        })),
-    };
-});
-vi.mock('../utils/helpers/helpers', async () => {
-    const actual = await vi.importActual('../utils/helpers/helpers');
-    return {
-        ...actual,
-        baseUrlFromChainId: vi.fn(() => 'https://0x.shapeshift.com/ethereum/'),
-    };
-});
-vi.mock('@shapeshiftoss/chain-adapters', async () => {
-    const { KnownChainIds } = await import('@shapeshiftoss/types');
-    const actual = await vi.importActual('@shapeshiftoss/chain-adapters');
-    return {
-        ...actual,
-        isEvmChainId: vi.fn(() => true),
-        evmChainIds: [KnownChainIds.EthereumMainnet],
-        optimism: {
-            isOptimismChainAdapter: vi.fn(() => false),
-        },
-    };
-});
-const mockOk = Ok;
-const mockErr = Err;
-describe('getZrxTradeQuote', () => {
-    const zrxBaseUrl = 'https://0x.shapeshift.com/ethereum/';
-    const assertGetChainAdapter = (_chainId) => {
-        return {
-            getChainId: () => KnownChainIds.EthereumMainnet,
-            getGasFeeData: () => Promise.resolve(gasFeeData),
-        };
-    };
-    const zrxService = zrxServiceFactory({ baseUrl: zrxBaseUrl });
-    it('returns quote with fee data', async () => {
-        const { quoteInput } = setupQuote();
-        vi.mocked(zrxService.get).mockReturnValue(Promise.resolve(mockOk({
-            data: {
-                buyAmount: quoteInput.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                sellAmount: quoteInput.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                fees: {
-                    integratorFee: null,
-                    zeroExFee: {
-                        amount: '3978501710063',
-                        token: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
-                    },
-                },
-                transaction: {
-                    gas: '237315',
-                },
-                route: { fills: [] },
-                permit2: { eip712: {} },
-            },
-        })));
-        const maybeQuote = await getZrxTradeQuote(quoteInput, assertGetChainAdapter, { 'eip155:1/erc20:0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2': quoteInput.buyAsset }, zrxBaseUrl);
-        if (maybeQuote.isErr())
-            console.log(maybeQuote.unwrapErr());
-        expect(maybeQuote.isErr()).toBe(false);
-        const quote = maybeQuote.unwrap();
-        expect(quote.steps[0].feeData).toStrictEqual({
-            protocolFees: {
-                'eip155:1/erc20:0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2': {
-                    amountCryptoBaseUnit: '3978501710063',
-                    asset: quoteInput.buyAsset,
-                    requiresBalance: false,
-                },
-            },
-            networkFeeCryptoBaseUnit: '22507856397000000',
-        });
-        expect(quote.steps[0].rate).toBe('1');
-    });
-    it('bubbles up the zrxService Err from a bad zrx response', async () => {
-        const { quoteInput } = setupQuote();
-        vi.mocked(zrxService.get).mockReturnValue(Promise.resolve(mockErr({ some: 'error' })));
-        const maybeTradeQuote = await getZrxTradeQuote(quoteInput, assertGetChainAdapter, {}, zrxBaseUrl);
-        expect(maybeTradeQuote.isErr()).toBe(true);
-        expect(maybeTradeQuote.unwrapErr()).toMatchObject({
-            some: 'error',
-        });
-    });
-    it('returns an Err on errored zrx response', async () => {
-        const { quoteInput } = setupQuote();
-        vi.mocked(zrxService.get).mockResolvedValue(Err({
-            response: { data: { code: 502, reason: 'Failed to do some stuff' } },
-        }));
-        const maybeTradeQuote = await getZrxTradeQuote(quoteInput, assertGetChainAdapter, {}, zrxBaseUrl);
-        expect(maybeTradeQuote.isErr()).toBe(true);
-        expect(maybeTradeQuote.unwrapErr()).toMatchObject({
-            response: { data: { code: 502, reason: 'Failed to do some stuff' } },
-        });
-    });
-    it('returns an Err on non ethereum chain for buyAsset', async () => {
-        const { quoteInput } = setupQuote();
-        vi.mocked(zrxService.get).mockReturnValue(Promise.resolve(Ok({})));
-        const maybeTradeQuote = await getZrxTradeQuote({ ...quoteInput, buyAsset: BTC }, assertGetChainAdapter, {}, zrxBaseUrl);
-        expect(maybeTradeQuote.isErr()).toBe(true);
-        expect(maybeTradeQuote.unwrapErr()).toMatchObject({
-            cause: undefined,
-            code: TradeQuoteError.UnsupportedChain,
-            message: 'unsupported chainId',
-            name: 'SwapError',
-        });
-    });
-    it('returns an Err on non ethereum chain for sellAsset', async () => {
-        const { quoteInput, sellAsset } = setupQuote();
-        vi.mocked(zrxService.get).mockReturnValue(Promise.resolve(Ok({})));
-        const maybeTradeQuote = await getZrxTradeQuote({ ...quoteInput, sellAsset: { ...sellAsset, chainId: btcChainId } }, assertGetChainAdapter, {}, zrxBaseUrl);
-        expect(maybeTradeQuote.isErr()).toBe(true);
-        expect(maybeTradeQuote.unwrapErr()).toMatchObject({
-            code: TradeQuoteError.UnsupportedChain,
-            details: {
-                chainId: 'bip122:000000000019d6689c085ae165831e93',
-            },
-            message: 'unsupported chainId',
-            name: 'SwapError',
-        });
-    });
-});

package/dist/esm/swappers/utils/filterBuyAssetsBySellAssetId/filterBuyAssetsBySellAssetId.d.ts

@@ -1,4 +0,0 @@
-import type { Asset } from '@shapeshiftoss/types';
-import type { BuyAssetBySellIdInput } from '../../../types.js';
-export declare const filterSameChainEvmBuyAssetsBySellAssetId: (input: BuyAssetBySellIdInput) => Asset[];
-export declare const filterCrossChainEvmBuyAssetsBySellAssetId: (input: BuyAssetBySellIdInput) => Asset[];

package/dist/esm/swappers/utils/filterBuyAssetsBySellAssetId/filterBuyAssetsBySellAssetId.js

@@ -1,18 +0,0 @@
-import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
-const _filterEvmBuyAssetsBySellAssetId = ({ assets, sellAsset }, chainIdPredicate) => {
-    // evm only
-    if (!isEvmChainId(sellAsset.chainId))
-        return [];
-    return assets.filter(buyAsset => {
-        // evm only AND chain id predicate
-        return isEvmChainId(buyAsset.chainId) && chainIdPredicate(buyAsset.chainId, sellAsset.chainId);
-    });
-};
-export const filterSameChainEvmBuyAssetsBySellAssetId = (input) => {
-    const sameChainIdPredicate = (buyAssetChainId, sellAssetChainId) => buyAssetChainId === sellAssetChainId;
-    return _filterEvmBuyAssetsBySellAssetId(input, sameChainIdPredicate);
-};
-export const filterCrossChainEvmBuyAssetsBySellAssetId = (input) => {
-    const crossChainIdPredicate = (buyAssetChainId, sellAssetChainId) => buyAssetChainId !== sellAssetChainId;
-    return _filterEvmBuyAssetsBySellAssetId(input, crossChainIdPredicate);
-};

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

@@ -1,8 +0,0 @@
-import { thorchainChainId } from '@shapeshiftoss/caip';
-import { describe, expect, it } from 'vitest';
-import { getTreasuryAddressFromChainId } from './helpers.js';
-describe('getTreasuryAddressFromChainId', () => {
-    it('throws for unsupported chains', () => {
-        expect(() => getTreasuryAddressFromChainId(thorchainChainId)).toThrow('[getTreasuryAddressFromChainId] - Unsupported chainId');
-    });
-});

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

@@ -1,5 +0,0 @@
-export declare const marketDataByAssetIdUsd: {
-    [x: string]: {
-        price: string;
-    };
-};

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

@@ -1,2 +0,0 @@
-import type { evm } from '@shapeshiftoss/chain-adapters';
-export declare const gasFeeData: evm.GasFeeDataEstimate;

package/dist/esm/swappers/utils/test-data/fees.js

@@ -1,17 +0,0 @@
-export const gasFeeData = {
-    fast: {
-        gasPrice: '79036500000',
-        maxFeePerGas: '216214758112',
-        maxPriorityFeePerGas: '2982734547',
-    },
-    slow: {
-        gasPrice: '79036500000',
-        maxFeePerGas: '216214758112',
-        maxPriorityFeePerGas: '2982734547',
-    },
-    average: {
-        gasPrice: '79036500000',
-        maxFeePerGas: '216214758112',
-        maxPriorityFeePerGas: '2982734547',
-    },
-};

package/dist/esm/thorchain-utils/cosmossdk/getCosmosSdkTransactionFees.js

@@ -1,11 +0,0 @@
-import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
-export const getCosmosSdkTransactionFees = async (args) => {
-    const { stepIndex, tradeQuote, assertGetCosmosSdkChainAdapter } = args;
-    if (!isExecutableTradeQuote(tradeQuote))
-        throw new Error('Unable to execute trade');
-    const step = getExecutableTradeStep(tradeQuote, stepIndex);
-    const { sellAsset } = step;
-    const adapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
-    const { fast } = await adapter.getFeeData({});
-    return fast.txFee;
-};

package/dist/esm/thorchain-utils/cosmossdk/getThorTxData.d.ts

@@ -1,12 +0,0 @@
-import type { Asset } from '@shapeshiftoss/types';
-import type { SwapperConfig, SwapperName } from '../../types.js';
-type GetThorTxDataArgs = {
-    sellAsset: Asset;
-    config: SwapperConfig;
-    swapperName: SwapperName;
-};
-type GetThorTxDataReturn = {
-    vault: string;
-};
-export declare const getThorTxData: ({ sellAsset, config, swapperName, }: GetThorTxDataArgs) => Promise<GetThorTxDataReturn>;
-export {};

package/dist/esm/thorchain-utils/cosmossdk/getThorTxData.js

@@ -1,15 +0,0 @@
-import { getInboundAddressDataForChain } from '../getInboundAddressDataForChain.js';
-import { getChainIdBySwapper, getDaemonUrl } from '../index.js';
-export const getThorTxData = async ({ sellAsset, config, swapperName, }) => {
-    // Native assets on the swapper's own chain (RUNE on THORChain, CACAO on MAYAChain)
-    // deposit via MsgDeposit and have no recipient address.
-    if (sellAsset.chainId === getChainIdBySwapper(swapperName))
-        return { vault: '' };
-    // Everything else (e.g. ATOM via THORChain, RUNE via MAYAChain) sends via MsgSend
-    // to the swapper's inbound vault on that chain.
-    const daemonUrl = getDaemonUrl(config, swapperName);
-    const res = await getInboundAddressDataForChain(daemonUrl, sellAsset.assetId, true, swapperName);
-    if (res.isErr())
-        throw res.unwrapErr();
-    return { vault: res.unwrap().address };
-};

package/dist/esm/thorchain-utils/cosmossdk/index.d.ts

@@ -1,2 +0,0 @@
-export * from './getCosmosSdkTransactionFees.js';
-export * from './getThorTxData.js';

package/dist/esm/thorchain-utils/cosmossdk/index.js

@@ -1,2 +0,0 @@
-export * from './getCosmosSdkTransactionFees.js';
-export * from './getThorTxData.js';

package/dist/esm/thorchain-utils/evm/getEvmData.d.ts

@@ -1,13 +0,0 @@
-import type { SwapperConfig, SwapperName, TradeQuoteStep } from '../../types.js';
-import type { ThorEvmTradeQuote } from '../types.js';
-type GetEvmDataArgs = {
-    config: SwapperConfig;
-    step: TradeQuoteStep;
-    tradeQuote: ThorEvmTradeQuote;
-    swapperName: SwapperName;
-};
-export declare const getEvmData: ({ config, step, tradeQuote, swapperName }: GetEvmDataArgs) => Promise<{
-    data: string;
-    to: string;
-}>;
-export {};

package/dist/esm/thorchain-utils/evm/getEvmData.js

@@ -1,87 +0,0 @@
-import { assertUnreachable, BigNumber, bn, bnOrZero } from '@shapeshiftoss/utils';
-import assert from 'assert';
-import { getCallDataFromQuote } from '../getCallDataFromQuote.js';
-import { TradeType } from '../types.js';
-import { getThorTxData } from './getThorTxData.js';
-export const getEvmData = async ({ config, step, tradeQuote, swapperName }) => {
-    const { router, vault, aggregator, memo: tcMemo, tradeType, expiry, longtailData, slippageTolerancePercentageDecimal, } = tradeQuote;
-    if (!tcMemo)
-        throw new Error('Cannot execute Tx without a memo');
-    const { sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset } = step;
-    switch (tradeType) {
-        case TradeType.L1ToL1: {
-            const data = await getCallDataFromQuote({
-                data: tradeQuote.data,
-                tradeType,
-                sellAsset,
-                sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                memo: tcMemo,
-                expiry,
-                config,
-                longtailData,
-                slippageTolerancePercentageDecimal,
-                vault,
-                swapperName,
-            });
-            return { data, to: router };
-        }
-        case TradeType.LongTailToL1: {
-            assert(aggregator, 'aggregator required for thorchain longtail to l1 swaps');
-            const expectedAmountOut = longtailData?.longtailToL1ExpectedAmountOut ?? '0';
-            // Paranoia assertion - expectedAmountOut should never be 0 as it would likely lead to a loss of funds.
-            assert(bnOrZero(expectedAmountOut).gt(0), 'expected expectedAmountOut to be a positive amount');
-            const amountOutMin = BigInt(bnOrZero(expectedAmountOut)
-                .times(bn(1).minus(slippageTolerancePercentageDecimal ?? 0))
-                .toFixed(0, BigNumber.ROUND_UP));
-            // Paranoia: ensure we have this to prevent sandwich attacks on the first step of a LongtailToL1 trade.
-            assert(amountOutMin > 0n, 'expected expectedAmountOut to be a positive amount');
-            const tcVault = vault;
-            const data = await getCallDataFromQuote({
-                data: tradeQuote.data,
-                tradeType,
-                sellAsset,
-                sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                memo: tcMemo,
-                expiry,
-                config,
-                longtailData,
-                slippageTolerancePercentageDecimal,
-                vault: tcVault,
-                swapperName,
-            });
-            return { data, to: aggregator };
-        }
-        case TradeType.L1ToLongTail: {
-            const expectedAmountOut = longtailData?.L1ToLongtailExpectedAmountOut ?? '0';
-            // Paranoia assertion - expectedAmountOut should never be 0 as it would likely lead to a loss of funds.
-            assert(bnOrZero(expectedAmountOut).gt(0), 'expected expectedAmountOut to be a positive amount');
-            const { router: updatedRouter } = await getThorTxData({
-                sellAsset,
-                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                memo: tcMemo,
-                expiry,
-                config,
-                swapperName,
-            });
-            assert(router, 'router required for l1 to thorchain longtail swaps');
-            const data = await getCallDataFromQuote({
-                data: tradeQuote.data,
-                tradeType,
-                sellAsset,
-                sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                memo: tcMemo,
-                expiry,
-                config,
-                longtailData,
-                slippageTolerancePercentageDecimal,
-                vault,
-                swapperName,
-            });
-            return { data, to: updatedRouter };
-        }
-        case TradeType.LongTailToLongTail:
-            throw Error(`Unsupported trade type: ${TradeType}`);
-        default:
-            return assertUnreachable(tradeType);
-    }
-};

package/dist/esm/thorchain-utils/evm/getEvmTransactionFees.d.ts

@@ -1,2 +0,0 @@
-import type { GetUnsignedEvmTransactionArgs, SwapperName } from '../../types.js';
-export declare const getEvmTransactionFees: (args: GetUnsignedEvmTransactionArgs, swapperName: SwapperName) => Promise<string>;

package/dist/esm/thorchain-utils/evm/getEvmTransactionFees.js

@@ -1,19 +0,0 @@
-import { evm } from '@shapeshiftoss/chain-adapters';
-import { isNativeEvmAsset } from '../../swappers/utils/helpers/helpers.js';
-import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
-import { getEvmData } from './getEvmData.js';
-export const getEvmTransactionFees = async (args, swapperName) => {
-    const { from, stepIndex, supportsEIP1559, assertGetEvmChainAdapter, config } = args;
-    const tradeQuote = args.tradeQuote;
-    if (!isExecutableTradeQuote(tradeQuote))
-        throw new Error('Unable to execute a trade rate quote');
-    const step = getExecutableTradeStep(tradeQuote, stepIndex);
-    const { sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset } = step;
-    const { data, to } = await getEvmData({ config, step, tradeQuote, swapperName });
-    const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-    const value = isNativeEvmAsset(sellAsset.assetId)
-        ? sellAmountIncludingProtocolFeesCryptoBaseUnit
-        : '0';
-    const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
-    return feeData.networkFeeCryptoBaseUnit;
-};

package/dist/esm/thorchain-utils/evm/getThorTxData.js

@@ -1,29 +0,0 @@
-import { fromAssetId } from '@shapeshiftoss/caip';
-import { getAddress } from 'viem';
-import { isNativeEvmAsset } from '../../swappers/utils/helpers/helpers.js';
-import { getInboundAddressDataForChain } from '../getInboundAddressDataForChain.js';
-import { getDaemonUrl } from '../index.js';
-import { depositWithExpiry } from '../routerCallData/routerCalldata.js';
-export const getThorTxData = async ({ sellAsset, sellAmountCryptoBaseUnit, memo, expiry, config, swapperName, }) => {
-    const { assetReference } = fromAssetId(sellAsset.assetId);
-    const daemonUrl = getDaemonUrl(config, swapperName);
-    const res = await getInboundAddressDataForChain(daemonUrl, sellAsset.assetId, true, swapperName);
-    if (res.isErr())
-        throw res.unwrapErr();
-    const inboundAddress = res.unwrap();
-    const router = getAddress(inboundAddress.router ?? '');
-    const vault = getAddress(inboundAddress.address);
-    if (!router) {
-        throw Error(`No router found for ${sellAsset.assetId} at inbound address ${inboundAddress}`);
-    }
-    const data = depositWithExpiry({
-        vault,
-        asset: isNativeEvmAsset(sellAsset.assetId)
-            ? '0x0000000000000000000000000000000000000000'
-            : getAddress(assetReference),
-        amount: BigInt(sellAmountCryptoBaseUnit),
-        memo,
-        expiry: BigInt(expiry),
-    });
-    return { data, router, vault };
-};

package/dist/esm/thorchain-utils/evm/getUnsignedEvmTransaction.js

@@ -1,19 +0,0 @@
-import { evm } from '@shapeshiftoss/chain-adapters';
-import { isNativeEvmAsset } from '../../swappers/utils/helpers/helpers.js';
-import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
-import { getEvmData } from './getEvmData.js';
-export const getUnsignedEvmTransaction = async (args, swapperName) => {
-    const { from, stepIndex, supportsEIP1559, assertGetEvmChainAdapter, config } = args;
-    const tradeQuote = args.tradeQuote;
-    if (!isExecutableTradeQuote(tradeQuote))
-        throw new Error('Unable to execute a trade rate quote');
-    const step = getExecutableTradeStep(tradeQuote, stepIndex);
-    const { accountNumber, sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset } = step;
-    const value = isNativeEvmAsset(sellAsset.assetId)
-        ? sellAmountIncludingProtocolFeesCryptoBaseUnit
-        : '0';
-    const { data, to } = await getEvmData({ config, step, tradeQuote, swapperName });
-    const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-    const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
-    return adapter.buildCustomApiTx({ accountNumber, data, from, to, value, ...feeData });
-};

package/dist/esm/thorchain-utils/evm/index.d.ts

@@ -1,3 +0,0 @@
-export * from './getThorTxData.js';
-export * from './getUnsignedEvmTransaction.js';
-export * from './getEvmTransactionFees.js';

package/dist/esm/thorchain-utils/evm/index.js

@@ -1,3 +0,0 @@
-export * from './getThorTxData.js';
-export * from './getUnsignedEvmTransaction.js';
-export * from './getEvmTransactionFees.js';

package/dist/esm/thorchain-utils/getCallDataFromQuote.d.ts

@@ -1,9 +0,0 @@
-import type { Asset } from '@shapeshiftoss/types';
-import type { SwapperConfig, SwapperName } from '../types.js';
-import type { ThorEvmTradeQuote } from './types.js';
-export declare const getCallDataFromQuote: ({ tradeType, data, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, memo: tcMemo, expiry, config, longtailData, slippageTolerancePercentageDecimal, vault, swapperName, }: Pick<ThorEvmTradeQuote, "data" | "slippageTolerancePercentageDecimal" | "memo" | "expiry" | "tradeType" | "aggregator" | "vault" | "longtailData"> & {
-    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
-    config: SwapperConfig;
-    sellAsset: Asset;
-    swapperName: SwapperName;
-}) => Promise<string>;