@shapeshiftoss/swapper 17.7.3 → 18.1.0

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

@@ -1,53 +0,0 @@
-import { TronWeb } from 'tronweb';
-import { SUNIO_SMART_ROUTER_CONTRACT } from './constants.js';
-const convertAddressesToEvmFormat = (value) => {
-    if (Array.isArray(value)) {
-        return value.map(v => convertAddressesToEvmFormat(v));
-    }
-    if (typeof value === 'string' && value.startsWith('T') && TronWeb.isAddress(value)) {
-        const hex = TronWeb.address.toHex(value);
-        return hex.replace(/^41/, '0x');
-    }
-    return value;
-};
-export const buildSunioSwapTransaction = async (args) => {
-    const { route, from, to, sellAmountCryptoBaseUnit, minBuyAmountCryptoBaseUnit, rpcUrl, deadline, } = args;
-    const tronWeb = new TronWeb({
-        fullHost: rpcUrl,
-    });
-    const path = route.tokens;
-    const poolVersion = route.poolVersions;
-    const versionLen = Array(poolVersion.length).fill(2);
-    const fees = route.poolFees.map(fee => Number(fee));
-    const swapData = {
-        amountIn: sellAmountCryptoBaseUnit,
-        amountOutMin: minBuyAmountCryptoBaseUnit,
-        recipient: to,
-        deadline: deadline ?? Math.floor(Date.now() / 1000) + 60 * 20,
-    };
-    const parameters = [
-        { type: 'address[]', value: path },
-        { type: 'string[]', value: poolVersion },
-        { type: 'uint256[]', value: versionLen },
-        { type: 'uint24[]', value: fees },
-        {
-            type: 'tuple(uint256,uint256,address,uint256)',
-            value: convertAddressesToEvmFormat([
-                swapData.amountIn,
-                swapData.amountOutMin,
-                swapData.recipient,
-                swapData.deadline,
-            ]),
-        },
-    ];
-    const functionSelector = 'swapExactInput(address[],string[],uint256[],uint24[],(uint256,uint256,address,uint256))';
-    const options = {
-        feeLimit: 100_000_000,
-        callValue: 0,
-    };
-    const txData = await tronWeb.transactionBuilder.triggerSmartContract(SUNIO_SMART_ROUTER_CONTRACT, functionSelector, options, parameters, from);
-    if (!txData.result || !txData.result.result) {
-        throw new Error('[Sun.io] Failed to build swap transaction');
-    }
-    return txData.transaction;
-};

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

@@ -1,4 +0,0 @@
-import type { Result } from '@sniptt/monads';
-import type { CommonTradeQuoteInput, GetTradeRateInput, GetTronTradeQuoteInput, SwapErrorRight, SwapperDeps, TradeQuote, TradeRate } from '../../../types.js';
-export declare function getQuoteOrRate(input: GetTronTradeQuoteInput | CommonTradeQuoteInput, deps: SwapperDeps): Promise<Result<TradeQuote, SwapErrorRight>>;
-export declare function getQuoteOrRate(input: GetTradeRateInput, deps: SwapperDeps): Promise<Result<TradeRate, SwapErrorRight>>;

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

@@ -1,210 +0,0 @@
-import { tronChainId } from '@shapeshiftoss/caip';
-import { BigAmount, bn, contractAddressOrUndefined } from '@shapeshiftoss/utils';
-import { Err, Ok } from '@sniptt/monads';
-import { TronWeb } from 'tronweb';
-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 { 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,
-            }));
-        }
-        // Fetch network fees for both quotes and rates (when wallet connected)
-        let networkFeeCryptoBaseUnit = undefined;
-        // Estimate fees when we have an address to estimate from
-        if (receiveAddress) {
-            try {
-                const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
-                const isSellingNativeTrx = !contractAddress;
-                const tronWeb = new TronWeb({ fullHost: deps.config.VITE_TRON_NODE_URL });
-                // Get chain parameters for pricing
-                const params = await tronWeb.trx.getChainParameters();
-                const bandwidthPrice = params.find(p => p.key === 'getTransactionFee')?.value ?? 1000;
-                const energyPrice = params.find(p => p.key === 'getEnergyFee')?.value ?? 100;
-                // Check if recipient needs activation (applies to all swaps)
-                let accountActivationFee = 0;
-                try {
-                    const recipientInfoResponse = await fetch(`${deps.config.VITE_TRON_NODE_URL}/wallet/getaccount`, {
-                        method: 'POST',
-                        headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify({ address: receiveAddress, visible: true }),
-                    });
-                    const recipientInfo = await recipientInfoResponse.json();
-                    const recipientExists = recipientInfo && Object.keys(recipientInfo).length > 1;
-                    if (!recipientExists) {
-                        accountActivationFee = 1_000_000; // 1 TRX
-                    }
-                }
-                catch {
-                    // Ignore activation check errors
-                }
-                // For native TRX swaps, Sun.io uses a contract call with value
-                // We need to estimate energy for the swap contract, not just bandwidth
-                if (isSellingNativeTrx) {
-                    try {
-                        // Sun.io contract owner provides most energy (~117k), users only pay ~2k
-                        // Use fixed 2k energy estimate instead of querying (which returns total 120k)
-                        const energyUsed = 2000; // User pays ~2k energy, contract covers the rest
-                        const energyFee = energyUsed * energyPrice; // No multiplier - contract provides energy
-                        // Estimate bandwidth for contract call (much larger than simple transfer)
-                        const bandwidthFee = 1100 * bandwidthPrice; // ~1100 bytes for contract call (with safety buffer)
-                        networkFeeCryptoBaseUnit = bn(energyFee)
-                            .plus(bandwidthFee)
-                            .plus(accountActivationFee)
-                            .toFixed(0);
-                    }
-                    catch (estimationError) {
-                        // Fallback estimate: ~2k energy + ~1100 bytes bandwidth + activation fee
-                        const fallbackEnergyFee = 2000 * energyPrice;
-                        const fallbackBandwidthFee = 1100 * bandwidthPrice;
-                        networkFeeCryptoBaseUnit = bn(fallbackEnergyFee)
-                            .plus(fallbackBandwidthFee)
-                            .plus(accountActivationFee)
-                            .toFixed(0);
-                    }
-                }
-                else {
-                    // For TRC-20 swaps through Sun.io router
-                    // Same as TRX: contract owner provides most energy, user pays ~2k
-                    // Sun.io provides ~217k energy, user pays ~2k
-                    const energyFee = 2000 * energyPrice;
-                    const bandwidthFee = 1100 * bandwidthPrice;
-                    networkFeeCryptoBaseUnit = bn(energyFee)
-                        .plus(bandwidthFee)
-                        .plus(accountActivationFee)
-                        .toFixed(0);
-                }
-            }
-            catch (error) {
-                // For rates, fall back to '0' on estimation failure
-                // For quotes, let it error (required for accurate swap)
-                if (!isQuote) {
-                    networkFeeCryptoBaseUnit = '0';
-                }
-                else {
-                    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>;