@shapeshiftoss/swapper 17.8.0 → 18.1.0

package/dist/esm/thorchain-utils/getCallDataFromQuote.js

@@ -1,50 +0,0 @@
-import { fromAssetId } from '@shapeshiftoss/caip';
-import { THOR_ROUTER_CONTRACT_MAINNET } from '@shapeshiftoss/contracts';
-import { assertUnreachable, BigNumber, bn, bnOrZero } from '@shapeshiftoss/utils';
-import { encodeFunctionData, parseAbiItem } from 'viem';
-import { getThorTxData } from './evm/index.js';
-import { TradeType } from './types.js';
-export const getCallDataFromQuote = async ({ tradeType, data, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, memo: tcMemo, expiry, config, longtailData, slippageTolerancePercentageDecimal, vault, swapperName, }) => {
-    switch (tradeType) {
-        case TradeType.L1ToL1: {
-            return data;
-        }
-        case TradeType.LongTailToL1: {
-            const expectedAmountOut = longtailData?.longtailToL1ExpectedAmountOut ?? '0';
-            const amountOutMin = BigInt(bnOrZero(expectedAmountOut)
-                .times(bn(1).minus(slippageTolerancePercentageDecimal ?? 0))
-                .toFixed(0, BigNumber.ROUND_UP));
-            const swapInAbiItem = parseAbiItem('function swapIn(address tcRouter, address tcVault, string tcMemo, address token, uint256 amount, uint256 amountOutMin, uint256 deadline)');
-            // Long-tails are only supported on mainnet
-            const tcRouter = THOR_ROUTER_CONTRACT_MAINNET;
-            const tcVault = vault;
-            const token = fromAssetId(sellAsset.assetId).assetReference;
-            const amount = BigInt(sellAmountIncludingProtocolFeesCryptoBaseUnit);
-            const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
-            const tenMinutes = BigInt(600);
-            const deadline = currentTimestamp + tenMinutes;
-            const params = [tcRouter, tcVault, tcMemo, token, amount, amountOutMin, deadline];
-            const swapInData = encodeFunctionData({
-                abi: [swapInAbiItem],
-                functionName: 'swapIn',
-                args: params,
-            });
-            return swapInData;
-        }
-        case TradeType.L1ToLongTail: {
-            const { data: dataWithAmountOut } = await getThorTxData({
-                sellAsset,
-                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                memo: tcMemo,
-                expiry,
-                config,
-                swapperName,
-            });
-            return dataWithAmountOut;
-        }
-        case TradeType.LongTailToLongTail:
-            throw Error(`Unsupported trade type: ${TradeType}`);
-        default:
-            return assertUnreachable(tradeType);
-    }
-};

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

@@ -1,6 +0,0 @@
-import type { Result } from '@sniptt/monads';
-import type { CommonTradeQuoteInput, GetTradeRateInput, SwapErrorRight, SwapperDeps, SwapperName } from '../types.js';
-import type { ThorTradeQuote, ThorTradeRate, TradeType } from './types.js';
-type ThorTradeRateOrQuote = ThorTradeRate | ThorTradeQuote;
-export declare const getL1RateOrQuote: <T extends ThorTradeRateOrQuote>(input: T extends ThorTradeRate ? GetTradeRateInput : CommonTradeQuoteInput, deps: SwapperDeps, streamingInterval: number, tradeType: TradeType, swapperName: SwapperName) => Promise<Result<T[], SwapErrorRight>>;
-export {};

package/dist/esm/thorchain-utils/getL1RateOrQuote.js

@@ -1,473 +0,0 @@
-import { CHAIN_NAMESPACE, fromAssetId } from '@shapeshiftoss/caip';
-import * as adapters from '@shapeshiftoss/chain-adapters';
-import { assertUnreachable, BigAmount, bn, bnOrZero, contractAddressOrUndefined, convertDecimalPercentageToBasisPoints, convertPrecision, isFulfilled, isRejected, } from '@shapeshiftoss/utils';
-import { Err, Ok } from '@sniptt/monads';
-import { PublicKey, SystemProgram, TransactionInstruction } from '@solana/web3.js';
-import { TronWeb } from 'tronweb';
-import { v4 as uuid } from 'uuid';
-import { getDefaultSlippageDecimalPercentageForSwapper } from '../index.js';
-import { buildAffiliateFee } from '../swappers/utils/affiliateFee.js';
-import { isNativeEvmAsset } from '../swappers/utils/helpers/helpers.js';
-import { TradeQuoteError } from '../types.js';
-import { getInputOutputRate, makeSwapErrorRight } from '../utils.js';
-import * as cosmossdk from './cosmossdk/index.js';
-import * as evm from './evm/index.js';
-import { getLimitWithManualSlippage } from './getLimitWithManualSlippage/getLimitWithManualSlippage.js';
-import { getQuote } from './getQuote.js';
-import { addLimitToMemo, assertAndProcessMemo, getAffiliate, getNativePrecision, getSwapSource, } from './index.js';
-import * as solana from './solana/index.js';
-import * as tron from './tron/index.js';
-import * as utxo from './utxo/index.js';
-const SAFE_GAS_LIMIT = '100000'; // depositWithExpiry()
-const SOLANA_MEMO_PROGRAM_ID = 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr';
-export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType, swapperName) => {
-    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmountCryptoBaseUnit, accountNumber, receiveAddress, affiliateBps: requestedAffiliateBps, } = input;
-    const { config, assertGetEvmChainAdapter, assertGetUtxoChainAdapter, assertGetCosmosSdkChainAdapter, assertGetSolanaChainAdapter, } = deps;
-    // "NativePrecision" is intended to indicate the base unit precision of the asset
-    // for the corresponding swapper network (THORChain or MAYAChain)
-    // (CACAO = 10, everything else = 8)
-    const sellAssetNativePrecision = getNativePrecision(sellAsset.assetId, swapperName);
-    const buyAssetNativePrecision = getNativePrecision(buyAsset.assetId, swapperName);
-    const { chainNamespace } = fromAssetId(sellAsset.assetId);
-    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
-        getDefaultSlippageDecimalPercentageForSwapper(swapperName);
-    const inputSlippageBps = convertDecimalPercentageToBasisPoints(slippageTolerancePercentageDecimal);
-    const baseQuoteArgs = {
-        sellAsset,
-        buyAssetId: buyAsset.assetId,
-        sellAmountCryptoBaseUnit,
-        receiveAddress,
-        affiliateBps: requestedAffiliateBps,
-        swapperName,
-    };
-    const maybeSwapQuote = await getQuote({ ...baseQuoteArgs, streaming: false }, deps);
-    const maybeStreamingSwapQuote = await getQuote({ ...baseQuoteArgs, streaming: true, streamingInterval }, deps);
-    if (maybeSwapQuote.isErr() && maybeStreamingSwapQuote.isErr()) {
-        return Err(maybeSwapQuote.unwrapErr());
-    }
-    const swapQuote = maybeSwapQuote.isOk() ? maybeSwapQuote.unwrap() : undefined;
-    const streamingSwapQuote = maybeStreamingSwapQuote.isOk()
-        ? maybeStreamingSwapQuote.unwrap()
-        : undefined;
-    const getRouteValues = (quote, isStreaming) => {
-        const source = getSwapSource(tradeType, isStreaming, swapperName);
-        return {
-            source,
-            quote,
-            expectedAmountOutThorBaseUnit: bnOrZero(quote.expected_amount_out).toFixed(),
-            isStreaming,
-            affiliateBps: quote.fees.affiliate === '0' ? '0' : requestedAffiliateBps,
-            // always use auto stream slippage limit (0 limit = 5bps - 50bps, sometimes up to 100bps)
-            // see: https://discord.com/channels/838986635756044328/1166265575941619742/1166500062101250100
-            slippageBps: isStreaming ? bn(0) : inputSlippageBps,
-            estimatedExecutionTimeMs: quote.total_swap_seconds
-                ? 1000 * quote.total_swap_seconds
-                : undefined,
-        };
-    };
-    const perRouteValues = [];
-    if (swapQuote)
-        perRouteValues.push(getRouteValues(swapQuote, false));
-    if (streamingSwapQuote)
-        perRouteValues.push(getRouteValues(streamingSwapQuote, true));
-    const recommendedMinAmountIn = swapQuote?.recommended_min_amount_in ?? streamingSwapQuote?.recommended_min_amount_in;
-    // recommended_min_amount_in should be the same value for both types of swaps
-    const recommendedMinimumCryptoBaseUnit = recommendedMinAmountIn
-        ? convertPrecision({
-            value: recommendedMinAmountIn,
-            inputExponent: sellAssetNativePrecision,
-            outputExponent: sellAsset.precision,
-        }).toFixed()
-        : '0';
-    const getRouteBuyAmountBeforeFeesCryptoBaseUnit = (quote) => {
-        const buyAmountBeforeFeesCryptoThorPrecision = bn(quote.expected_amount_out).plus(quote.fees.total);
-        return BigAmount.fromPrecision({
-            value: BigAmount.fromBaseUnit({
-                value: buyAmountBeforeFeesCryptoThorPrecision,
-                precision: buyAssetNativePrecision,
-            }).toPrecision(),
-            precision: buyAsset.precision,
-        }).toBaseUnit();
-    };
-    const getProtocolFees = (quote) => {
-        // Fees consist of liquidity, outbound, and affiliate fees
-        // For the purpose of displaying protocol fees to the user, we don't need the latter
-        // The reason for that is the affiliate fee is shown as its own "ShapeShift fee" section
-        // Including the affiliate fee here would result in the protocol fee being wrong, as affiliate fees would be
-        // double accounted for both in protocol fees, and affiliate fee
-        const buyAssetTradeFeeBuyAssetCryptoThorPrecision = bnOrZero(quote.fees.total).minus(quote.fees.affiliate);
-        const buyAssetTradeFeeBuyAssetCryptoBaseUnit = convertPrecision({
-            value: buyAssetTradeFeeBuyAssetCryptoThorPrecision,
-            inputExponent: buyAssetNativePrecision,
-            outputExponent: buyAsset.precision,
-        });
-        const protocolFees = {};
-        if (!buyAssetTradeFeeBuyAssetCryptoBaseUnit.isZero()) {
-            protocolFees[buyAsset.assetId] = {
-                amountCryptoBaseUnit: buyAssetTradeFeeBuyAssetCryptoBaseUnit.toFixed(0),
-                requiresBalance: false,
-                asset: buyAsset,
-            };
-        }
-        return protocolFees;
-    };
-    const getMemo = (route) => {
-        if (input.quoteOrRate === 'rate')
-            return '';
-        if (!route.quote.memo)
-            throw new Error('no memo provided');
-        // always use auto stream quote memo (0 limit = 5bps - 50bps, sometimes up to 100bps)
-        // see: https://discord.com/channels/838986635756044328/1166265575941619742/1166500062101250100
-        if (route.isStreaming)
-            return assertAndProcessMemo(route.quote.memo, getAffiliate(swapperName));
-        const limitWithManualSlippage = getLimitWithManualSlippage({
-            expectedAmountOutThorBaseUnit: route.expectedAmountOutThorBaseUnit,
-            slippageBps: route.slippageBps,
-        });
-        return addLimitToMemo({
-            memo: route.quote.memo,
-            limit: limitWithManualSlippage,
-            affilate: getAffiliate(swapperName),
-        });
-    };
-    const makeThorTradeRateOrQuote = ({ route, memo, allowanceContract, feeData, data, router, vault, thorchainTransactionMetadata, }) => {
-        const buyAmountAfterFeesCryptoBaseUnit = convertPrecision({
-            value: route.expectedAmountOutThorBaseUnit,
-            inputExponent: buyAssetNativePrecision,
-            outputExponent: buyAsset.precision,
-        }).toFixed(0);
-        const rate = getInputOutputRate({
-            sellAmountCryptoBaseUnit,
-            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-            sellAsset,
-            buyAsset,
-        });
-        const slippage = route.isStreaming ? undefined : slippageTolerancePercentageDecimal;
-        const buyAmountBeforeFeesCryptoBaseUnit = getRouteBuyAmountBeforeFeesCryptoBaseUnit(route.quote);
-        return {
-            id: uuid(),
-            quoteOrRate: input.quoteOrRate,
-            memo,
-            receiveAddress,
-            affiliateBps: route.affiliateBps,
-            isStreaming: route.isStreaming,
-            recommendedMinimumCryptoBaseUnit,
-            slippageTolerancePercentageDecimal: slippage,
-            rate,
-            data,
-            router,
-            vault,
-            expiry: route.quote.expiry,
-            tradeType,
-            swapperName,
-            steps: [
-                {
-                    estimatedExecutionTimeMs: route.estimatedExecutionTimeMs,
-                    rate,
-                    sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmountCryptoBaseUnit,
-                    buyAmountBeforeFeesCryptoBaseUnit,
-                    buyAmountAfterFeesCryptoBaseUnit,
-                    source: route.source,
-                    buyAsset,
-                    sellAsset,
-                    accountNumber,
-                    allowanceContract,
-                    feeData,
-                    affiliateFee: buildAffiliateFee({
-                        strategy: 'buy_asset',
-                        affiliateBps: route.affiliateBps,
-                        sellAsset,
-                        buyAsset,
-                        sellAmountCryptoBaseUnit,
-                        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-                    }),
-                    thorchainSpecific: {
-                        maxStreamingQuantity: route.quote.max_streaming_quantity,
-                    },
-                    thorchainTransactionMetadata,
-                },
-            ],
-        };
-    };
-    switch (chainNamespace) {
-        case CHAIN_NAMESPACE.Evm: {
-            const { supportsEIP1559 } = input;
-            const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-            const maybeRoutes = await Promise.allSettled(perRouteValues.map(async (route) => {
-                const memo = getMemo(route);
-                const { data, router, vault } = await evm.getThorTxData({
-                    sellAsset,
-                    sellAmountCryptoBaseUnit,
-                    memo,
-                    expiry: route.quote.expiry,
-                    config,
-                    swapperName,
-                });
-                const { average } = await adapter.getGasFeeData();
-                const networkFeeCryptoBaseUnit = adapters.evm.calcNetworkFeeCryptoBaseUnit({
-                    ...average,
-                    supportsEIP1559,
-                    gasLimit: SAFE_GAS_LIMIT,
-                });
-                return makeThorTradeRateOrQuote({
-                    route,
-                    memo,
-                    allowanceContract: router,
-                    data,
-                    router,
-                    vault,
-                    thorchainTransactionMetadata: {
-                        to: router,
-                        data,
-                        value: isNativeEvmAsset(sellAsset.assetId) ? sellAmountCryptoBaseUnit : '0',
-                    },
-                    feeData: {
-                        protocolFees: getProtocolFees(route.quote),
-                        networkFeeCryptoBaseUnit,
-                    },
-                });
-            }));
-            const routes = maybeRoutes.filter(isFulfilled).map(maybeRoute => maybeRoute.value);
-            if (!routes.length)
-                return Err(makeSwapErrorRight({
-                    message: 'Unable to create any routes',
-                    code: TradeQuoteError.UnsupportedTradePair,
-                    cause: maybeRoutes.filter(isRejected).map(maybeRoute => maybeRoute.reason),
-                }));
-            return Ok(routes);
-        }
-        case CHAIN_NAMESPACE.Utxo: {
-            const { xpub = '' } = input;
-            const sellAdapter = assertGetUtxoChainAdapter(sellAsset.chainId);
-            const maybeRoutes = await Promise.allSettled(perRouteValues.map(async (route) => {
-                const memo = getMemo(route);
-                const { vault } = await utxo.getThorTxData({
-                    sellAsset,
-                    config,
-                    swapperName,
-                });
-                const feeData = await (async () => {
-                    const protocolFees = getProtocolFees(route.quote);
-                    // This is a rate without a wallet connected, so we can't get fees
-                    if (!xpub)
-                        return { networkFeeCryptoBaseUnit: undefined, protocolFees };
-                    const { fast } = await sellAdapter.getFeeData({
-                        to: vault,
-                        value: sellAmountCryptoBaseUnit,
-                        chainSpecific: { pubkey: xpub, opReturnData: memo },
-                    });
-                    return {
-                        networkFeeCryptoBaseUnit: fast.txFee,
-                        protocolFees,
-                        chainSpecific: {
-                            satsPerByte: fast.chainSpecific.satoshiPerByte,
-                        },
-                    };
-                })();
-                return makeThorTradeRateOrQuote({
-                    route,
-                    allowanceContract: '0x0',
-                    memo,
-                    thorchainTransactionMetadata: {
-                        to: vault,
-                        memo,
-                        value: sellAmountCryptoBaseUnit,
-                    },
-                    feeData,
-                });
-            }));
-            const routes = maybeRoutes.filter(isFulfilled).map(maybeRoute => maybeRoute.value);
-            if (!routes.length)
-                return Err(makeSwapErrorRight({
-                    message: 'Unable to create any routes',
-                    code: TradeQuoteError.UnsupportedTradePair,
-                    cause: maybeRoutes.filter(isRejected).map(maybeRoute => maybeRoute.reason),
-                }));
-            return Ok(routes);
-        }
-        case CHAIN_NAMESPACE.CosmosSdk: {
-            const cosmosChainAdapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
-            const { fast } = await cosmosChainAdapter.getFeeData({});
-            const { vault } = await cosmossdk.getThorTxData({ sellAsset, config, swapperName });
-            return Ok(perRouteValues.map((route) => {
-                const memo = getMemo(route);
-                return makeThorTradeRateOrQuote({
-                    route,
-                    memo,
-                    allowanceContract: '0x0',
-                    thorchainTransactionMetadata: {
-                        to: vault,
-                        memo,
-                        value: sellAmountCryptoBaseUnit,
-                    },
-                    feeData: {
-                        networkFeeCryptoBaseUnit: fast.txFee,
-                        protocolFees: getProtocolFees(route.quote),
-                        chainSpecific: {
-                            estimatedGasCryptoBaseUnit: fast.chainSpecific.gasLimit,
-                        },
-                    },
-                });
-            }));
-        }
-        case CHAIN_NAMESPACE.Solana: {
-            const adapter = assertGetSolanaChainAdapter(sellAsset.chainId);
-            const sendAddress = input.sendAddress;
-            const { vault } = await solana.getThorTxData({ sellAsset, config, swapperName });
-            const maybeRoutes = await Promise.allSettled(perRouteValues.map(async (route) => {
-                const memo = getMemo(route);
-                const protocolFees = getProtocolFees(route.quote);
-                const feeData = await (async () => {
-                    if (!sendAddress)
-                        return { networkFeeCryptoBaseUnit: undefined, protocolFees };
-                    const memoInstruction = new TransactionInstruction({
-                        keys: [],
-                        programId: new PublicKey(SOLANA_MEMO_PROGRAM_ID),
-                        data: Buffer.from(memo, 'utf8'),
-                    });
-                    const transferInstruction = SystemProgram.transfer({
-                        fromPubkey: new PublicKey(sendAddress),
-                        toPubkey: new PublicKey(vault),
-                        lamports: BigInt(sellAmountCryptoBaseUnit),
-                    });
-                    const { fast } = await adapter.getFeeData({
-                        to: vault,
-                        value: '0',
-                        chainSpecific: {
-                            from: sendAddress,
-                            tokenId: contractAddressOrUndefined(sellAsset.assetId),
-                            instructions: [memoInstruction, transferInstruction],
-                        },
-                    });
-                    return { networkFeeCryptoBaseUnit: fast.txFee, protocolFees };
-                })();
-                return makeThorTradeRateOrQuote({
-                    route,
-                    allowanceContract: '0x0',
-                    memo,
-                    thorchainTransactionMetadata: {
-                        to: vault,
-                        memo,
-                        value: sellAmountCryptoBaseUnit,
-                    },
-                    feeData,
-                });
-            }));
-            const routes = maybeRoutes.filter(isFulfilled).map(r => r.value);
-            if (!routes.length)
-                return Err(makeSwapErrorRight({
-                    message: 'Unable to create any routes',
-                    code: TradeQuoteError.UnsupportedTradePair,
-                    cause: maybeRoutes.filter(isRejected).map(r => r.reason),
-                }));
-            return Ok(routes);
-        }
-        case CHAIN_NAMESPACE.Tron: {
-            const { vault } = await tron.getThorTxData({ sellAsset, config, swapperName });
-            const maybeRoutes = await Promise.allSettled(perRouteValues.map(async (route) => {
-                const memo = getMemo(route);
-                let networkFeeCryptoBaseUnit = undefined;
-                // Calculate fees for rates when we have a receive address (wallet connected)
-                if (input.quoteOrRate === 'rate' && input.receiveAddress && vault) {
-                    try {
-                        const { sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
-                        const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
-                        // Estimate fees using the receive address for accurate energy calculation
-                        const tronWeb = new TronWeb({
-                            fullHost: deps.config.VITE_TRON_NODE_URL,
-                            headers: deps.config.VITE_TRON_GRID_API_KEY
-                                ? { 'TRON-PRO-API-KEY': deps.config.VITE_TRON_GRID_API_KEY }
-                                : {},
-                        });
-                        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;
-                        let totalFee = 0;
-                        if (contractAddress) {
-                            // TRC20: Estimate energy with actual recipient
-                            try {
-                                const result = await tronWeb.transactionBuilder.triggerConstantContract(contractAddress, 'transfer(address,uint256)', {}, [
-                                    { type: 'address', value: vault },
-                                    {
-                                        type: 'uint256',
-                                        value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                                    },
-                                ], input.receiveAddress);
-                                const energyUsed = result.energy_used ?? 65000;
-                                const energyFee = energyUsed * energyPrice * 1.5; // 1.5x safety margin
-                                const bandwidthFee = 276 * bandwidthPrice; // TRC20 bandwidth
-                                totalFee = Math.ceil(energyFee + bandwidthFee);
-                            }
-                            catch {
-                                // Fallback: Conservative estimate
-                                totalFee = 13_000_000; // 13 TRX worst case
-                            }
-                        }
-                        else {
-                            // TRX transfer bandwidth: Base tx + memo bytes
-                            const baseBytes = 198;
-                            const memoBytes = route.quote.memo
-                                ? Buffer.from(route.quote.memo, 'utf8').length
-                                : 0;
-                            const totalBandwidth = baseBytes + memoBytes;
-                            totalFee = totalBandwidth * bandwidthPrice;
-                        }
-                        networkFeeCryptoBaseUnit = String(totalFee);
-                    }
-                    catch {
-                        // Leave as undefined if estimation fails
-                    }
-                }
-                // For quotes, fees will be calculated in getTronTransactionFees when executing
-                return Promise.resolve(makeThorTradeRateOrQuote({
-                    route,
-                    allowanceContract: '0x0',
-                    memo,
-                    thorchainTransactionMetadata: {
-                        to: vault,
-                        memo,
-                        value: sellAmountCryptoBaseUnit,
-                    },
-                    feeData: {
-                        networkFeeCryptoBaseUnit,
-                        protocolFees: getProtocolFees(route.quote),
-                    },
-                }));
-            }));
-            const routes = maybeRoutes.filter(isFulfilled).map(maybeRoute => maybeRoute.value);
-            if (!routes.length)
-                return Err(makeSwapErrorRight({
-                    message: 'Unable to create any routes',
-                    code: TradeQuoteError.UnsupportedTradePair,
-                    cause: maybeRoutes.filter(isRejected).map(maybeRoute => maybeRoute.reason),
-                }));
-            return Ok(routes);
-        }
-        case CHAIN_NAMESPACE.Sui: {
-            return Err(makeSwapErrorRight({
-                message: 'SUI is not supported',
-                code: TradeQuoteError.UnsupportedTradePair,
-            }));
-        }
-        case CHAIN_NAMESPACE.Near: {
-            return Err(makeSwapErrorRight({
-                message: 'NEAR is not supported',
-                code: TradeQuoteError.UnsupportedTradePair,
-            }));
-        }
-        case CHAIN_NAMESPACE.Starknet: {
-            return Err(makeSwapErrorRight({
-                message: 'Starknet is not supported',
-                code: TradeQuoteError.UnsupportedTradePair,
-            }));
-        }
-        case CHAIN_NAMESPACE.Ton: {
-            return Err(makeSwapErrorRight({
-                message: 'TON is not supported',
-                code: TradeQuoteError.UnsupportedTradePair,
-            }));
-        }
-        default:
-            return assertUnreachable(chainNamespace);
-    }
-};

package/dist/esm/thorchain-utils/routerCallData/routerCalldata.d.ts

@@ -1,8 +0,0 @@
-import type { Address } from 'viem';
-export declare const depositWithExpiry: ({ vault, asset, amount, memo, expiry, }: {
-    vault: Address;
-    asset: Address;
-    amount: bigint;
-    memo: string;
-    expiry: bigint;
-}) => `0x${string}`;

package/dist/esm/thorchain-utils/routerCallData/routerCalldata.js

@@ -1,10 +0,0 @@
-import { THORCHAIN_ROUTER_ABI } from '@shapeshiftoss/contracts';
-import { encodeFunctionData } from 'viem';
-export const depositWithExpiry = ({ vault, asset, amount, memo, expiry, }) => {
-    const data = encodeFunctionData({
-        abi: THORCHAIN_ROUTER_ABI,
-        functionName: 'depositWithExpiry',
-        args: [vault, asset, amount, memo, expiry],
-    });
-    return data;
-};

package/dist/esm/thorchain-utils/solana/constants.d.ts

@@ -1 +0,0 @@
-export declare const MEMO_PROGRAM_ID = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";

package/dist/esm/thorchain-utils/solana/constants.js

@@ -1,3 +0,0 @@
-// Solana Memo Program v2
-// https://spl.solana.com/memo
-export const MEMO_PROGRAM_ID = 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr';

package/dist/esm/thorchain-utils/solana/getSolanaTransactionFees.d.ts

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

package/dist/esm/thorchain-utils/solana/getSolanaTransactionFees.js

@@ -1,37 +0,0 @@
-import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
-import { PublicKey, SystemProgram, TransactionInstruction } from '@solana/web3.js';
-import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
-import { getThorTxData } from './getThorTxData.js';
-const MEMO_PROGRAM_ID = 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr';
-export const getSolanaTransactionFees = async (args, swapperName) => {
-    const { tradeQuote, stepIndex, from, assertGetSolanaChainAdapter, config } = args;
-    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 { sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset } = step;
-    const { vault } = await getThorTxData({ sellAsset, config, swapperName });
-    const adapter = assertGetSolanaChainAdapter(sellAsset.chainId);
-    const memoInstruction = new TransactionInstruction({
-        keys: [],
-        programId: new PublicKey(MEMO_PROGRAM_ID),
-        data: Buffer.from(memo, 'utf8'),
-    });
-    const transferInstruction = SystemProgram.transfer({
-        fromPubkey: new PublicKey(from),
-        toPubkey: new PublicKey(vault),
-        lamports: BigInt(sellAmountIncludingProtocolFeesCryptoBaseUnit),
-    });
-    const { fast } = await adapter.getFeeData({
-        to: vault,
-        value: '0',
-        chainSpecific: {
-            from,
-            tokenId: contractAddressOrUndefined(sellAsset.assetId),
-            instructions: [memoInstruction, transferInstruction],
-        },
-    });
-    return fast.txFee;
-};

package/dist/esm/thorchain-utils/solana/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/solana/getThorTxData.js

@@ -1,10 +0,0 @@
-import { getInboundAddressDataForChain } from '../getInboundAddressDataForChain.js';
-import { getDaemonUrl } from '../index.js';
-export const getThorTxData = async ({ sellAsset, config, swapperName, }) => {
-    const daemonUrl = getDaemonUrl(config, swapperName);
-    const res = await getInboundAddressDataForChain(daemonUrl, sellAsset.assetId, false, swapperName);
-    if (res.isErr())
-        throw res.unwrapErr();
-    const { address: vault } = res.unwrap();
-    return { vault };
-};

package/dist/esm/thorchain-utils/solana/getUnsignedSolanaTransaction.d.ts

@@ -1,3 +0,0 @@
-import type { SolanaSignTx } from '@shapeshiftoss/hdwallet-core';
-import type { GetUnsignedSolanaTransactionArgs, SwapperName } from '../../types.js';
-export declare const getUnsignedSolanaTransaction: (args: GetUnsignedSolanaTransactionArgs, swapperName: SwapperName) => Promise<SolanaSignTx>;