@shapeshiftoss/swapper 17.7.3 → 18.1.0

package/dist/cjs/utils/thorchain/getThorStepData.js

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThorStepData = exports.THOR_SOLANA_COMPUTE_BUDGET = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const contracts_1 = require("@shapeshiftoss/contracts");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const tronweb_1 = require("tronweb");
+const viem_1 = require("viem");
+const types_1 = require("../../types");
+const utils_2 = require("../../utils");
+const evm_1 = require("../evm");
+const helpers_1 = require("../helpers");
+const solana_1 = require("../solana");
+const utxo_1 = require("../utxo");
+const getThorTxData_1 = require("./getThorTxData");
+const routerCalldata_1 = require("./routerCallData/routerCalldata");
+const types_2 = require("./types");
+// depositWithExpiry() measured at 44k (native) / 74k (erc20) on mainnet
+const SAFE_NATIVE_DEPOSIT_GAS_LIMIT = '50000';
+const SAFE_TOKEN_DEPOSIT_GAS_LIMIT = '85000';
+// The deposit is a fixed transfer (150 CU) + memo (~370 CU/byte, 20k-45k measured on mainnet),
+// so the estimate is exact and the margin is safety only
+exports.THOR_SOLANA_COMPUTE_BUDGET = { marginMultiplier: 1.1 };
+// swapIn() bundles a uniswap v3 swap ahead of the deposit, measured at 206k-222k on mainnet across
+// usdc/usdt/link/uni/wbtc and both the 0.05% and 0.3% pools
+const SAFE_SWAP_IN_GAS_LIMIT = '250000';
+async function getThorStepData({ type, input, from, deps, swapperName, tradeType, sellAsset, sellAmountCryptoBaseUnit, memo, expiry, rawMemo, longtail, }) {
+    const { config } = deps;
+    const { chainNamespace } = (0, caip_1.fromAssetId)(sellAsset.assetId);
+    try {
+        switch (chainNamespace) {
+            case caip_1.CHAIN_NAMESPACE.Evm: {
+                const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
+                const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+                const { router, vault } = await (0, getThorTxData_1.getThorRouterAndVault)({ sellAsset, config, swapperName });
+                // LongTailToL1 executes swapIn against an aggregator, every other trade type deposits directly
+                const buildData = (txMemo) => {
+                    if (longtail) {
+                        return (0, routerCalldata_1.swapIn)({
+                            tcRouter: contracts_1.THOR_ROUTER_CONTRACT_MAINNET,
+                            tcVault: vault,
+                            tcMemo: txMemo,
+                            token: (0, viem_1.getAddress)((0, caip_1.fromAssetId)(sellAsset.assetId).assetReference),
+                            amount: BigInt(sellAmountCryptoBaseUnit),
+                            amountOutMin: longtail.amountOutMin,
+                            deadline: longtail.deadline,
+                        });
+                    }
+                    return (0, routerCalldata_1.depositWithExpiry)({
+                        vault,
+                        asset: (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId)
+                            ? viem_1.zeroAddress
+                            : (0, viem_1.getAddress)((0, caip_1.fromAssetId)(sellAsset.assetId).assetReference),
+                        amount: BigInt(sellAmountCryptoBaseUnit),
+                        memo: txMemo,
+                        expiry: BigInt(expiry),
+                    });
+                };
+                const data = buildData(memo);
+                const safeGasLimit = (() => {
+                    if (tradeType === types_2.TradeType.LongTailToL1)
+                        return SAFE_SWAP_IN_GAS_LIMIT;
+                    return (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId)
+                        ? SAFE_NATIVE_DEPOSIT_GAS_LIMIT
+                        : SAFE_TOKEN_DEPOSIT_GAS_LIMIT;
+                })();
+                const buildTransactionData = (txMemo) => ({
+                    type: 'evm',
+                    chainId: Number((0, caip_1.fromChainId)(sellAsset.chainId).chainReference),
+                    to: longtail ? longtail.aggregator : router,
+                    data: buildData(txMemo),
+                    value: !longtail && (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId) ? sellAmountCryptoBaseUnit : '0',
+                });
+                // Longtail swapIn pulls tokens through the transfer proxy, not the aggregator itself
+                const spenderAddress = longtail
+                    ? contracts_1.TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET
+                    : router;
+                if (type === 'rate') {
+                    const networkFeeCryptoBaseUnit = await (async () => {
+                        if (input.sendAddress) {
+                            try {
+                                return await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+                                    adapter,
+                                    transactionData: buildTransactionData(rawMemo ?? ''),
+                                    from: input.sendAddress,
+                                    supportsEIP1559,
+                                    stateOverride: {
+                                        sellAsset,
+                                        sellAmountCryptoBaseUnit,
+                                        spenderAddress,
+                                    },
+                                });
+                            }
+                            catch {
+                                // Estimation failed - use safe gas limit
+                            }
+                        }
+                        return (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+                            adapter,
+                            supportsEIP1559,
+                            gasLimit: safeGasLimit,
+                        });
+                    })();
+                    const stepData = { router, data, networkFeeCryptoBaseUnit };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                const transactionData = buildTransactionData(memo);
+                try {
+                    const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+                        adapter,
+                        transactionData,
+                        from,
+                        supportsEIP1559,
+                        stateOverride: {
+                            sellAsset,
+                            sellAmountCryptoBaseUnit,
+                            spenderAddress,
+                        },
+                    });
+                    const stepData = {
+                        router,
+                        data,
+                        transactionData,
+                        networkFeeCryptoBaseUnit,
+                    };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                catch (error) {
+                    return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getThorStepData', error));
+                }
+            }
+            case caip_1.CHAIN_NAMESPACE.Utxo: {
+                const xpub = 'xpub' in input ? input.xpub : undefined;
+                const adapter = deps.assertGetUtxoChainAdapter(sellAsset.chainId);
+                const { vault } = await (0, getThorTxData_1.getThorTxData)({ sellAsset, config, swapperName });
+                const { networkFeeCryptoBaseUnit } = await (0, utxo_1.getUtxoNetworkFeeCryptoBaseUnit)({
+                    adapter,
+                    pubkey: xpub,
+                    to: vault,
+                    value: sellAmountCryptoBaseUnit,
+                    // Rates size the op_return with the raw thornode memo (processed memo is '' for rates)
+                    opReturnData: type === 'quote' ? memo : rawMemo,
+                });
+                if (type === 'rate') {
+                    const stepData = { networkFeeCryptoBaseUnit };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                const stepData = {
+                    transactionData: {
+                        type: 'utxo',
+                        to: vault,
+                        opReturnData: memo,
+                        value: sellAmountCryptoBaseUnit,
+                    },
+                    networkFeeCryptoBaseUnit,
+                };
+                return (0, monads_1.Ok)(stepData);
+            }
+            case caip_1.CHAIN_NAMESPACE.CosmosSdk: {
+                const adapter = deps.assertGetCosmosSdkChainAdapter(sellAsset.chainId);
+                const { fast } = await adapter.getFeeData({});
+                const { vault } = await (0, getThorTxData_1.getThorTxData)({ sellAsset, config, swapperName });
+                if (type === 'rate') {
+                    const stepData = { networkFeeCryptoBaseUnit: fast.txFee };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                if (vault) {
+                    // Blockchain-literal denom so consumers can construct the MsgSend amount
+                    const denom = (() => {
+                        if (sellAsset.assetId === caip_1.cosmosAssetId)
+                            return 'uatom';
+                        if (sellAsset.assetId === caip_1.thorchainAssetId)
+                            return 'rune';
+                        return undefined;
+                    })();
+                    if (!denom) {
+                        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                            message: `Unsupported sellAsset: ${sellAsset.assetId}`,
+                            code: types_1.TradeQuoteError.UnsupportedTradePair,
+                        }));
+                    }
+                    const stepData = {
+                        transactionData: {
+                            type: 'cosmossdk_msg_send',
+                            chainId: sellAsset.chainId,
+                            to: vault,
+                            denom,
+                            value: sellAmountCryptoBaseUnit,
+                            memo,
+                        },
+                        networkFeeCryptoBaseUnit: fast.txFee,
+                    };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                // Native sells (no vault) are MsgDeposits; the coin must be explicit as the thorchain
+                // adapter otherwise defaults to THOR.RUNE
+                const coin = (() => {
+                    if (sellAsset.assetId === caip_1.thorchainAssetId)
+                        return 'THOR.RUNE';
+                    if (sellAsset.assetId === caip_1.tcyAssetId)
+                        return 'THOR.TCY';
+                    if (sellAsset.assetId === caip_1.rujiAssetId)
+                        return 'THOR.RUJI';
+                    if (sellAsset.assetId === caip_1.mayachainAssetId)
+                        return 'MAYA.CACAO';
+                    return undefined;
+                })();
+                if (!coin) {
+                    return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                        message: `Unsupported sellAsset: ${sellAsset.assetId}`,
+                        code: types_1.TradeQuoteError.UnsupportedTradePair,
+                    }));
+                }
+                const stepData = {
+                    transactionData: {
+                        type: 'cosmossdk_msg_deposit',
+                        chainId: sellAsset.chainId,
+                        value: sellAmountCryptoBaseUnit,
+                        memo,
+                        coin,
+                    },
+                    networkFeeCryptoBaseUnit: fast.txFee,
+                };
+                return (0, monads_1.Ok)(stepData);
+            }
+            case caip_1.CHAIN_NAMESPACE.Solana: {
+                const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+                const tokenId = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
+                const { vault } = await (0, getThorTxData_1.getThorTxData)({ sellAsset, config, swapperName });
+                const buildInstructions = (address, value) => adapter.buildTransferInstructions({
+                    from: address,
+                    to: vault,
+                    tokenId,
+                    value,
+                    // Rates size the memo instruction with the raw thornode memo (processed memo is '' for rates)
+                    memo: type === 'quote' ? memo : rawMemo,
+                });
+                if (type === 'rate') {
+                    // Without a connected wallet the funded vault stands in as payer with a 1 lamport
+                    // self-transfer, simulating the same instruction shape (compute cost is amount independent)
+                    const address = from ?? vault;
+                    const value = from ? sellAmountCryptoBaseUnit : '1';
+                    const { networkFeeCryptoBaseUnit } = await (0, solana_1.getSolanaNetworkFeeCryptoBaseUnit)({
+                        adapter,
+                        from: address,
+                        instructions: await buildInstructions(address, value),
+                    });
+                    const stepData = { networkFeeCryptoBaseUnit };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                const instructions = await buildInstructions(from, sellAmountCryptoBaseUnit);
+                const { networkFeeCryptoBaseUnit, feeData, includeComputeBudget } = await (0, solana_1.getSolanaNetworkFeeCryptoBaseUnit)({
+                    adapter,
+                    from,
+                    instructions,
+                });
+                const stepData = {
+                    transactionData: {
+                        type: 'solana_instructions',
+                        instructions: (0, solana_1.withComputeUnitLimit)({
+                            instructions,
+                            computeUnits: feeData.chainSpecific.computeUnits,
+                            includeComputeBudget,
+                            computeBudget: exports.THOR_SOLANA_COMPUTE_BUDGET,
+                        }),
+                        addressLookupTableAddresses: [],
+                    },
+                    networkFeeCryptoBaseUnit,
+                };
+                return (0, monads_1.Ok)(stepData);
+            }
+            case caip_1.CHAIN_NAMESPACE.Tron: {
+                const { vault } = await (0, getThorTxData_1.getThorTxData)({ sellAsset, config, swapperName });
+                const networkFeeCryptoBaseUnit = await (async () => {
+                    // Fees are calculated for rates with a wallet connected - quotes calculate them at
+                    // execution via getTronTransactionFees
+                    if (!(type === 'rate' && input.receiveAddress && vault))
+                        return undefined;
+                    try {
+                        const contractAddress = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
+                        // Estimate fees using the receive address for accurate energy calculation
+                        const tronWeb = new tronweb_1.TronWeb({
+                            fullHost: config.VITE_TRON_NODE_URL,
+                            headers: config.VITE_TRON_GRID_API_KEY
+                                ? { 'TRON-PRO-API-KEY': 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;
+                        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: sellAmountCryptoBaseUnit },
+                                ], input.receiveAddress);
+                                const energyUsed = result.energy_used ?? 65000;
+                                const energyFee = energyUsed * energyPrice * 1.5; // 1.5x safety margin
+                                const bandwidthFee = 276 * bandwidthPrice; // TRC20 bandwidth
+                                return String(Math.ceil(energyFee + bandwidthFee));
+                            }
+                            catch {
+                                // Fallback: Conservative estimate
+                                return String(13_000_000); // 13 TRX worst case
+                            }
+                        }
+                        // TRX transfer bandwidth: Base tx + memo bytes
+                        const baseBytes = 198;
+                        const memoBytes = rawMemo ? Buffer.from(rawMemo, 'utf8').length : 0;
+                        const totalBandwidth = baseBytes + memoBytes;
+                        return String(totalBandwidth * bandwidthPrice);
+                    }
+                    catch {
+                        // Leave as undefined if estimation fails
+                        return undefined;
+                    }
+                })();
+                if (type === 'rate') {
+                    const stepData = { networkFeeCryptoBaseUnit };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                // Un-migrated - exec builds its tx from the inbound address, so no transactionData is carried
+                const stepData = { networkFeeCryptoBaseUnit };
+                return (0, monads_1.Ok)(stepData);
+            }
+            default:
+                return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                    message: `Unsupported chainNamespace: ${chainNamespace}`,
+                    code: types_1.TradeQuoteError.UnsupportedChain,
+                }));
+        }
+    }
+    catch (error) {
+        return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getThorStepData', error));
+    }
+}
+exports.getThorStepData = getThorStepData;

package/dist/cjs/{thorchain-utils/evm → utils/thorchain}/getThorTxData.d.ts

@@ -3,16 +3,14 @@ import type { Address } from 'viem';
 import type { SwapperConfig, SwapperName } from '../../types';
 type GetThorTxDataArgs = {
     sellAsset: Asset;
-    sellAmountCryptoBaseUnit: string;
-    memo: string;
-    expiry: number;
     config: SwapperConfig;
     swapperName: SwapperName;
 };
-type GetThorTxDataReturn = {
-    data: string;
+export declare const getThorTxData: (args: GetThorTxDataArgs) => Promise<{
+    vault: string;
+}>;
+export declare const getThorRouterAndVault: (args: GetThorTxDataArgs) => Promise<{
     router: Address;
     vault: Address;
-};
-export declare const getThorTxData: ({ sellAsset, sellAmountCryptoBaseUnit, memo, expiry, config, swapperName, }: GetThorTxDataArgs) => Promise<GetThorTxDataReturn>;
+}>;
 export {};

package/dist/cjs/utils/thorchain/getThorTxData.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThorRouterAndVault = exports.getThorTxData = void 0;
+const utils_1 = require("@shapeshiftoss/utils");
+const viem_1 = require("viem");
+const getInboundAddressDataForChain_1 = require("./getInboundAddressDataForChain");
+const index_1 = require("./index");
+const getInboundAddress = async ({ sellAsset, config, swapperName }) => {
+    const daemonUrl = (0, index_1.getDaemonUrl)(config, swapperName);
+    // Inbound addresses are per chain, so look up via the chain's fee asset - the sell asset itself
+    // may not be a pool asset (e.g. longtail tokens)
+    const assetId = (0, utils_1.chainIdToFeeAssetId)(sellAsset.chainId);
+    const res = await (0, getInboundAddressDataForChain_1.getInboundAddressDataForChain)(daemonUrl, assetId, true, swapperName);
+    if (res.isErr())
+        throw res.unwrapErr();
+    return res.unwrap();
+};
+const getThorTxData = async (args) => {
+    const { sellAsset, swapperName } = args;
+    // 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 === (0, index_1.getChainIdBySwapper)(swapperName))
+        return { vault: '' };
+    const { address: vault } = await getInboundAddress(args);
+    return { vault };
+};
+exports.getThorTxData = getThorTxData;
+const getThorRouterAndVault = async (args) => {
+    const inboundAddress = await getInboundAddress(args);
+    if (!inboundAddress.router) {
+        throw Error(`No router found for ${args.sellAsset.assetId} at inbound address ${inboundAddress.address}`);
+    }
+    return { router: (0, viem_1.getAddress)(inboundAddress.router), vault: (0, viem_1.getAddress)(inboundAddress.address) };
+};
+exports.getThorRouterAndVault = getThorRouterAndVault;

package/dist/cjs/{thorchain-utils → utils/thorchain}/index.d.ts

@@ -1,21 +1,21 @@
 import type { AssetId } from '@shapeshiftoss/caip';
-import type { SwapperConfig, SwapSource, TradeQuote, TradeRate } from '../types';
-import { SwapperName } from '../types';
+import type { SwapperConfig, SwapSource, TradeQuote, TradeRate } from '../../types';
+import { SwapperName } from '../../types';
 import type { ThorTradeQuote, ThorTradeRate } from './types';
 import { TradeType } from './types';
 export * from './checkTradeStatus';
 export * from './getInboundAddressDataForChain';
+export * from './getThorStepData';
+export * from './getThorTxData';
 export * from './memo';
 export * from './routerCallData/routerCalldata';
 export * from './service';
 export * from './types';
-export * from './getL1RateOrQuote';
+export * from './getThorL1TradeContexts';
+export * from './getThorL1TradeQuote';
+export * from './getThorL1TradeRate';
 export * from './getPoolDetails';
-export * as cosmossdk from './cosmossdk';
-export * as evm from './evm';
-export * as solana from './solana';
 export * as tron from './tron';
-export * as utxo from './utxo';
 export declare const getChainIdBySwapper: (swapperName: SwapperName) => import("@shapeshiftoss/caip").ChainId;
 export declare const isThorTradeRate: (quote: TradeRate | undefined) => quote is ThorTradeRate;
 export declare const isThorTradeQuote: (quote: TradeQuote | undefined) => quote is ThorTradeQuote;
@@ -23,8 +23,6 @@ export declare const getDaemonUrl: (config: SwapperConfig, swapperName: SwapperN
 export declare const getMidgardUrl: (config: SwapperConfig, swapperName: SwapperName) => string;
 export declare const isNativeAsset: (assetId: AssetId, swapperName: SwapperName) => boolean;
 export declare const getNativePrecision: (assetId: AssetId, swapperName: SwapperName) => 8 | 10;
-export declare const getSwapperNativeAssetId: (swapperName: SwapperName) => AssetId;
-export declare const getNativeFee: (swapperName: SwapperName) => "2000000" | "2000000000";
 export declare const getAffiliate: (swapperName: SwapperName) => "ss" | "ssmaya";
 export declare const getPoolAssetId: ({ assetId, swapperName, }: {
     assetId: AssetId;

package/dist/cjs/{thorchain-utils → utils/thorchain}/index.js

@@ -15,6 +15,9 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -22,30 +25,26 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSwapSource = exports.getPoolAssetId = exports.getAffiliate = exports.getNativeFee = exports.getSwapperNativeAssetId = exports.getNativePrecision = exports.isNativeAsset = exports.getMidgardUrl = exports.getDaemonUrl = exports.isThorTradeQuote = exports.isThorTradeRate = exports.getChainIdBySwapper = exports.utxo = exports.tron = exports.solana = exports.evm = exports.cosmossdk = void 0;
+exports.getSwapSource = exports.getPoolAssetId = exports.getAffiliate = exports.getNativePrecision = exports.isNativeAsset = exports.getMidgardUrl = exports.getDaemonUrl = exports.isThorTradeQuote = exports.isThorTradeRate = exports.getChainIdBySwapper = exports.tron = void 0;
 const caip_1 = require("@shapeshiftoss/caip");
-const adapters = __importStar(require("@shapeshiftoss/chain-adapters"));
-const MayachainSwapper_1 = require("../swappers/MayachainSwapper");
-const ThorchainSwapper_1 = require("../swappers/ThorchainSwapper");
-const types_1 = require("../types");
+const MayachainSwapper_1 = require("../../swappers/MayachainSwapper");
+const ThorchainSwapper_1 = require("../../swappers/ThorchainSwapper");
+const types_1 = require("../../types");
 const types_2 = require("./types");
 __exportStar(require("./checkTradeStatus"), exports);
 __exportStar(require("./getInboundAddressDataForChain"), exports);
+__exportStar(require("./getThorStepData"), exports);
+__exportStar(require("./getThorTxData"), exports);
 __exportStar(require("./memo"), exports);
 __exportStar(require("./routerCallData/routerCalldata"), exports);
 __exportStar(require("./service"), exports);
 __exportStar(require("./types"), exports);
-__exportStar(require("./getL1RateOrQuote"), exports);
+__exportStar(require("./getThorL1TradeContexts"), exports);
+__exportStar(require("./getThorL1TradeQuote"), exports);
+__exportStar(require("./getThorL1TradeRate"), exports);
 __exportStar(require("./getPoolDetails"), exports);
-exports.cosmossdk = __importStar(require("./cosmossdk"));
-exports.evm = __importStar(require("./evm"));
-exports.solana = __importStar(require("./solana"));
 exports.tron = __importStar(require("./tron"));
-exports.utxo = __importStar(require("./utxo"));
 const getChainIdBySwapper = (swapperName) => {
     switch (swapperName) {
         case types_1.SwapperName.Thorchain:
@@ -105,28 +104,6 @@ const getNativePrecision = (assetId, swapperName) => {
     }
 };
 exports.getNativePrecision = getNativePrecision;
-const getSwapperNativeAssetId = (swapperName) => {
-    switch (swapperName) {
-        case types_1.SwapperName.Thorchain:
-            return caip_1.thorchainAssetId;
-        case types_1.SwapperName.Mayachain:
-            return caip_1.mayachainAssetId;
-        default:
-            throw new Error(`Invalid swapper: ${swapperName}`);
-    }
-};
-exports.getSwapperNativeAssetId = getSwapperNativeAssetId;
-const getNativeFee = (swapperName) => {
-    switch (swapperName) {
-        case types_1.SwapperName.Thorchain:
-            return adapters.thorchain.NATIVE_FEE;
-        case types_1.SwapperName.Mayachain:
-            return adapters.mayachain.NATIVE_FEE;
-        default:
-            throw new Error(`Invalid swapper: ${swapperName}`);
-    }
-};
-exports.getNativeFee = getNativeFee;
 const getAffiliate = (swapperName) => {
     switch (swapperName) {
         case types_1.SwapperName.Thorchain:

package/dist/cjs/{thorchain-utils → utils/thorchain}/memo/index.test.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const vitest_1 = require("vitest");
-const ThorchainSwapper_1 = require("../../swappers/ThorchainSwapper");
+const ThorchainSwapper_1 = require("../../../swappers/ThorchainSwapper");
 const addAggregatorAddressToMemo_1 = require("./addAggregatorAddressToMemo");
 const addFinalAssetAddressToMemo_1 = require("./addFinalAssetAddressToMemo");
 const addFinalAssetLimitToMemo_1 = require("./addFinalAssetLimitToMemo");

package/dist/cjs/utils/thorchain/routerCallData/routerCalldata.d.ts

@@ -0,0 +1,17 @@
+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}`;
+export declare const swapIn: ({ tcRouter, tcVault, tcMemo, token, amount, amountOutMin, deadline, }: {
+    tcRouter: Address;
+    tcVault: Address;
+    tcMemo: string;
+    token: Address;
+    amount: bigint;
+    amountOutMin: bigint;
+    deadline: bigint;
+}) => `0x${string}`;

package/dist/cjs/utils/thorchain/routerCallData/routerCalldata.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swapIn = exports.depositWithExpiry = void 0;
+const contracts_1 = require("@shapeshiftoss/contracts");
+const viem_1 = require("viem");
+const SWAP_IN_ABI_ITEM = (0, viem_1.parseAbiItem)('function swapIn(address tcRouter, address tcVault, string tcMemo, address token, uint256 amount, uint256 amountOutMin, uint256 deadline)');
+const depositWithExpiry = ({ vault, asset, amount, memo, expiry, }) => {
+    const data = (0, viem_1.encodeFunctionData)({
+        abi: contracts_1.THORCHAIN_ROUTER_ABI,
+        functionName: 'depositWithExpiry',
+        args: [vault, asset, amount, memo, expiry],
+    });
+    return data;
+};
+exports.depositWithExpiry = depositWithExpiry;
+const swapIn = ({ tcRouter, tcVault, tcMemo, token, amount, amountOutMin, deadline, }) => {
+    const data = (0, viem_1.encodeFunctionData)({
+        abi: [SWAP_IN_ABI_ITEM],
+        functionName: 'swapIn',
+        args: [tcRouter, tcVault, tcMemo, token, amount, amountOutMin, deadline],
+    });
+    return data;
+};
+exports.swapIn = swapIn;

package/dist/cjs/{thorchain-utils → utils/thorchain}/service.d.ts

@@ -1,5 +1,5 @@
 export declare const thorService: {
-    get: <T = any>(url: string, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("..").SwapErrorRight>>;
-    post: <T_1 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_1, any, {}>, import("..").SwapErrorRight>>;
-    delete: <T_2 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_2, any, {}>, import("..").SwapErrorRight>>;
+    get: <T = any>(url: string, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("../..").SwapErrorRight>>;
+    post: <T_1 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_1, any, {}>, import("../..").SwapErrorRight>>;
+    delete: <T_2 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_2, any, {}>, import("../..").SwapErrorRight>>;
 };

package/dist/cjs/{thorchain-utils → utils/thorchain}/service.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.thorService = void 0;
-const utils_1 = require("../utils");
+const utils_1 = require("../../utils");
 // Important: maxAge should be small because inbound address info must be recent
 const maxAge = 5 * 1000; // 5 seconds
 const cachedUrls = ['/pools', '/inbound_addresses', '/pool/'];

package/dist/{esm/thorchain-utils → cjs/utils/thorchain}/tron/getTronTransactionFees.d.ts

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

package/dist/cjs/{thorchain-utils → utils/thorchain}/tron/getTronTransactionFees.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTronTransactionFees = void 0;
 const utils_1 = require("@shapeshiftoss/utils");
 const tronweb_1 = require("tronweb");
-const utils_2 = require("../../utils");
-const getThorTxData_1 = require("./getThorTxData");
-const getChainPrices = async (rpcUrl) => {
+const utils_2 = require("../../../utils");
+const getThorTxData_1 = require("../getThorTxData");
+const getChainPrices = async (rpcUrl, headers) => {
     try {
-        const tronWeb = new tronweb_1.TronWeb({ fullHost: rpcUrl });
+        const tronWeb = new tronweb_1.TronWeb({ fullHost: rpcUrl, headers });
         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 ?? 420;
@@ -29,11 +29,14 @@ const getTronTransactionFees = async (args, swapperName) => {
     const { vault } = await (0, getThorTxData_1.getThorTxData)({ sellAsset, config, swapperName });
     const contractAddress = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
     const rpcUrl = config.VITE_TRON_NODE_URL;
+    const tronGridHeaders = config.VITE_TRON_GRID_API_KEY
+        ? { 'TRON-PRO-API-KEY': config.VITE_TRON_GRID_API_KEY }
+        : {};
     try {
-        const tronWeb = new tronweb_1.TronWeb({ fullHost: rpcUrl });
+        const tronWeb = new tronweb_1.TronWeb({ fullHost: rpcUrl, headers: tronGridHeaders });
         if (contractAddress) {
             // TRC20 transfer - estimate energy cost
-            const { energyPrice } = await getChainPrices(rpcUrl);
+            const { energyPrice } = await getChainPrices(rpcUrl, tronGridHeaders);
             const result = await tronWeb.transactionBuilder.triggerConstantContract(contractAddress, 'transfer(address,uint256)', {}, [
                 { type: 'address', value: vault },
                 { type: 'uint256', value: sellAmountIncludingProtocolFeesCryptoBaseUnit },
@@ -44,7 +47,7 @@ const getTronTransactionFees = async (args, swapperName) => {
         }
         else {
             // TRX transfer with memo - build transaction to get accurate size
-            const { bandwidthPrice } = await getChainPrices(rpcUrl);
+            const { bandwidthPrice } = await getChainPrices(rpcUrl, tronGridHeaders);
             let tx = await tronWeb.transactionBuilder.sendTrx(vault, (0, utils_1.bnOrZero)(sellAmountIncludingProtocolFeesCryptoBaseUnit).toNumber(), from);
             // Add memo to get accurate size with memo overhead
             const txWithMemo = await tronWeb.transactionBuilder.addUpdateData(tx, memo, 'utf8');

package/dist/cjs/{thorchain-utils → utils/thorchain}/tron/getUnsignedTronTransaction.d.ts

@@ -1,3 +1,3 @@
 import type { tron } from '@shapeshiftoss/chain-adapters';
-import type { GetUnsignedTronTransactionArgs, SwapperName } from '../../types';
+import type { GetUnsignedTronTransactionArgs, SwapperName } from '../../../types';
 export declare const getUnsignedTronTransaction: (args: GetUnsignedTronTransactionArgs, swapperName: SwapperName) => Promise<tron.TronSignTx>;