@shapeshiftoss/swapper 20.2.0 → 20.3.0

package/dist/cjs/types.d.ts

@@ -12,14 +12,12 @@ import type { InterpolationOptions } from 'node-polyglot';
 import type { AvnuMetadata } from './swappers/AvnuSwapper/types';
 import type { BebopMetadata } from './swappers/BebopSwapper/types';
 import type { BobGatewayMetadata } from './swappers/BobGatewaySwapper/types';
-import type { ButterSwapTransactionMetadata } from './swappers/ButterSwap/types';
 import type { ChainflipMetadata } from './swappers/ChainflipSwapper/types';
 import type { CowMessageToSign } from './swappers/CowSwapper/types';
 import type { DebridgeMetadata } from './swappers/DebridgeSwapper/utils/types';
 import type { NearIntentsMetadata } from './swappers/NearIntentsSwapper/types';
-import type { RelayMetadata, RelayTransactionMetadata } from './swappers/RelaySwapper/utils/types';
+import type { RelayMetadata } from './swappers/RelaySwapper/utils/types';
 import type { StonfiMetadata, StonfiTransactionData } from './swappers/StonfiSwapper/types';
-import type { SunioTransactionData } from './swappers/SunioSwapper/types';
 import type { makeSwapperAxiosServiceMonadic } from './utils';
 import type { MayachainMetadata, ThorchainMetadata } from './utils/thorchain/types';
 export type SwapperConfig = {
@@ -323,8 +321,9 @@ export type TxBuildData = {
 } | {
     type: 'tron';
     to: string;
-    data: string;
     value: string;
+    data?: string;
+    memo?: string;
 } | {
     type: 'cowswap';
     chainId: ChainId;
@@ -344,9 +343,6 @@ export type TradeStepCommon = {
     estimatedExecutionTimeMs: number | undefined;
     swapperMetadata?: SwapperMetadata;
     stonfiTransactionData?: StonfiTransactionData;
-    sunioTransactionData?: SunioTransactionData;
-    relayTransactionMetadata?: RelayTransactionMetadata;
-    butterSwapTransactionMetadata?: ButterSwapTransactionMetadata;
     chainflipSpecific?: {
         depositAddress?: string;
     };
@@ -477,6 +473,11 @@ export type EvmMessageExecutionProps = {
 };
 export type UtxoTransactionExecutionProps = {
     signAndBroadcastTransaction: (txToSign: SignTx<UtxoChainId>) => Promise<string>;
+    signTransaction?: (txToSign: SignTx<UtxoChainId>) => Promise<string>;
+};
+export type UtxoTransactionExecutionContext = {
+    config: SwapperConfig;
+    swapperMetadata: SwapperMetadata | undefined;
 };
 export type CosmosSdkTransactionExecutionProps = {
     signAndBroadcastTransaction: (txToSign: SignTx<CosmosSdkChainId>) => Promise<string>;
@@ -587,7 +588,7 @@ export type Swapper = {
     supportsExternalPayment?: boolean;
     executeEvmTransaction?: (txToSign: SignTx<EvmChainId>, callbacks: EvmTransactionExecutionProps) => Promise<string>;
     executeEvmMessage?: (txMetaToSign: EvmMessageToSign, callbacks: EvmMessageExecutionProps, config: SwapperConfig) => Promise<string>;
-    executeUtxoTransaction?: (txToSign: SignTx<UtxoChainId>, callbacks: UtxoTransactionExecutionProps) => Promise<string>;
+    executeUtxoTransaction?: (txToSign: SignTx<UtxoChainId>, callbacks: UtxoTransactionExecutionProps, context?: UtxoTransactionExecutionContext) => Promise<string>;
     executeCosmosSdkTransaction?: (txToSign: SignTx<CosmosSdkChainId>, callbacks: CosmosSdkTransactionExecutionProps) => Promise<string>;
     executeSolanaTransaction?: (txToSign: SolanaSignTx, callbacks: SolanaTransactionExecutionProps) => Promise<string>;
     executeSolanaMessage?: (messageData: SolanaMessageToSign, callbacks: SolanaMessageExecutionProps, config: SwapperConfig) => Promise<string>;

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

@@ -5,7 +5,6 @@ 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");
@@ -272,58 +271,42 @@ async function getThorStepData({ type, input, from, deps, swapperName, tradeType
             }
             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;
-                    }
-                })();
+                const adapter = deps.assertGetTronChainAdapter(sellAsset.chainId);
+                const contractAddress = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
+                const estimate = async (txMemo) => {
+                    const { fast } = await adapter.getFeeData({
+                        to: vault,
+                        value: sellAmountCryptoBaseUnit,
+                        chainSpecific: {
+                            from,
+                            contractAddress,
+                            memo: txMemo,
+                            requireEnergyShare: type === 'quote',
+                        },
+                    });
+                    return fast.txFee;
+                };
                 if (type === 'rate') {
+                    // Rates size the memo with the raw thornode memo (processed memo is '' for rates)
+                    const networkFeeCryptoBaseUnit = await (async () => {
+                        try {
+                            return await estimate(rawMemo);
+                        }
+                        catch { }
+                    })();
                     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);
+                try {
+                    const stepData = {
+                        transactionData: { type: 'tron', to: vault, value: sellAmountCryptoBaseUnit, memo },
+                        networkFeeCryptoBaseUnit: await estimate(memo),
+                    };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                catch (error) {
+                    return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getThorStepData', error));
+                }
             }
             default:
                 return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({

package/dist/cjs/utils/thorchain/getThorStepData.tron.test.d.ts

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

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const caip_1 = require("@shapeshiftoss/caip");
+const vitest_1 = require("vitest");
+const types_1 = require("../../types");
+const assets_1 = require("../test-data/assets");
+const getThorStepData_1 = require("./getThorStepData");
+const types_2 = require("./types");
+vitest_1.vi.mock('./getThorTxData', () => ({
+    getThorTxData: vitest_1.vi.fn().mockResolvedValue({ vault: 'TVault' }),
+    getThorRouterAndVault: vitest_1.vi.fn(),
+}));
+const USDT = 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t';
+const USDT_TRON = { ...assets_1.ETH, assetId: `${caip_1.tronChainId}/trc20:${USDT}`, chainId: caip_1.tronChainId };
+const FROM = 'TT2T17KZhoDu47i2E4FWxfG79zdkEWkU9N';
+const tronAdapter = (txFee = '9000000') => ({
+    getFeeData: vitest_1.vi.fn().mockResolvedValue({ fast: { txFee } }),
+});
+const makeDeps = (tron) => ({ config: {}, assertGetTronChainAdapter: () => tron });
+const baseArgs = {
+    swapperName: types_1.SwapperName.Thorchain,
+    tradeType: types_2.TradeType.L1ToL1,
+    sellAsset: USDT_TRON,
+    sellAmountCryptoBaseUnit: '100000000',
+    expiry: 0,
+    rawMemo: '=:ETH.ETH:0xabc:1',
+};
+(0, vitest_1.describe)('getThorStepData tron', () => {
+    (0, vitest_1.it)('carries the vault transfer as transactionData and estimates it for a quote', async () => {
+        const adapter = tronAdapter();
+        const actual = await (0, getThorStepData_1.getThorStepData)({
+            ...baseArgs,
+            type: 'quote',
+            input: {},
+            deps: makeDeps(adapter),
+            from: FROM,
+            memo: '=:ETH.ETH:0xabc:1/1/0:ss:55',
+        });
+        (0, vitest_1.expect)(actual.unwrap()).toEqual({
+            transactionData: {
+                type: 'tron',
+                to: 'TVault',
+                value: '100000000',
+                memo: '=:ETH.ETH:0xabc:1/1/0:ss:55',
+            },
+            networkFeeCryptoBaseUnit: '9000000',
+        });
+        (0, vitest_1.expect)(adapter.getFeeData).toHaveBeenCalledWith({
+            to: 'TVault',
+            value: '100000000',
+            chainSpecific: {
+                from: FROM,
+                contractAddress: USDT,
+                memo: '=:ETH.ETH:0xabc:1/1/0:ss:55',
+                requireEnergyShare: true,
+            },
+        });
+    });
+    (0, vitest_1.it)('fails the quote when estimation fails', async () => {
+        const adapter = tronAdapter();
+        adapter.getFeeData.mockRejectedValue(new Error('rpc down'));
+        const actual = await (0, getThorStepData_1.getThorStepData)({
+            ...baseArgs,
+            type: 'quote',
+            input: {},
+            deps: makeDeps(adapter),
+            from: FROM,
+            memo: '=:ETH.ETH:0xabc:1/1/0:ss:55',
+        });
+        (0, vitest_1.expect)(actual.isErr()).toBe(true);
+    });
+    (0, vitest_1.it)('sizes a rate with the raw memo and no sender', async () => {
+        const adapter = tronAdapter();
+        const actual = await (0, getThorStepData_1.getThorStepData)({
+            ...baseArgs,
+            type: 'rate',
+            input: {},
+            deps: makeDeps(adapter),
+            memo: '',
+        });
+        (0, vitest_1.expect)(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '9000000' });
+        (0, vitest_1.expect)(adapter.getFeeData).toHaveBeenCalledWith({
+            to: 'TVault',
+            value: '100000000',
+            chainSpecific: {
+                from: undefined,
+                contractAddress: USDT,
+                memo: '=:ETH.ETH:0xabc:1',
+                requireEnergyShare: false,
+            },
+        });
+    });
+});

package/dist/cjs/utils/thorchain/index.d.ts

@@ -15,7 +15,6 @@ export * from './getThorL1TradeContexts';
 export * from './getThorL1TradeQuote';
 export * from './getThorL1TradeRate';
 export * from './getPoolDetails';
-export * as tron from './tron';
 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;

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

@@ -10,23 +10,11 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : 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 = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSwapSource = exports.getPoolAssetId = exports.getAffiliate = exports.getNativePrecision = exports.isNativeAsset = exports.getMidgardUrl = exports.getDaemonUrl = exports.isThorTradeQuote = exports.isThorTradeRate = exports.getChainIdBySwapper = exports.tron = void 0;
+exports.getSwapSource = exports.getPoolAssetId = exports.getAffiliate = exports.getNativePrecision = exports.isNativeAsset = exports.getMidgardUrl = exports.getDaemonUrl = exports.isThorTradeQuote = exports.isThorTradeRate = exports.getChainIdBySwapper = void 0;
 const caip_1 = require("@shapeshiftoss/caip");
 const MayachainSwapper_1 = require("../../swappers/MayachainSwapper");
 const ThorchainSwapper_1 = require("../../swappers/ThorchainSwapper");
@@ -44,7 +32,6 @@ __exportStar(require("./getThorL1TradeContexts"), exports);
 __exportStar(require("./getThorL1TradeQuote"), exports);
 __exportStar(require("./getThorL1TradeRate"), exports);
 __exportStar(require("./getPoolDetails"), exports);
-exports.tron = __importStar(require("./tron"));
 const getChainIdBySwapper = (swapperName) => {
     switch (swapperName) {
         case types_1.SwapperName.Thorchain:

package/dist/cjs/utils/tron/constants.d.ts

@@ -0,0 +1 @@
+export declare const TRON_PLACEHOLDER_ADDRESS = "TT2T17KZhoDu47i2E4FWxfG79zdkEWkU9N";

package/dist/cjs/utils/tron/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRON_PLACEHOLDER_ADDRESS = void 0;
+// An activated mainnet account, standing in as the sender/recipient for walletless rate estimation
+exports.TRON_PLACEHOLDER_ADDRESS = 'TT2T17KZhoDu47i2E4FWxfG79zdkEWkU9N';

package/dist/cjs/utils/tron/getTronNetworkFeeCryptoBaseUnit.d.ts

@@ -0,0 +1,27 @@
+import { tron } from '@shapeshiftoss/chain-adapters';
+import type { Asset } from '@shapeshiftoss/types';
+import type { TxBuildData } from '../../types';
+export type TronContractCall = Omit<Extract<TxBuildData, {
+    type: 'tron';
+}>, 'type' | 'data' | 'memo'> & {
+    data: string;
+};
+type GetTronContractCallFallbackFeeArgs = {
+    adapter: tron.ChainAdapter;
+    energy: string;
+    bandwidthBytes: number;
+    contractAddress?: string;
+    fullEnergyOnShareLookupFailure?: boolean;
+};
+export declare const getTronContractCallFallbackFeeCryptoBaseUnit: ({ adapter, energy, bandwidthBytes, contractAddress, fullEnergyOnShareLookupFailure, }: GetTronContractCallFallbackFeeArgs) => Promise<string>;
+type GetTronContractCallNetworkFeeArgs = {
+    adapter: tron.ChainAdapter;
+    transactionData: TronContractCall;
+    from: string;
+    sellAsset: Asset;
+    sellAmountCryptoBaseUnit: string;
+    spenderAddress: string;
+    fallbackEnergy: string;
+};
+export declare const getTronContractCallNetworkFeeCryptoBaseUnit: ({ adapter, transactionData, from, sellAsset, sellAmountCryptoBaseUnit, spenderAddress, fallbackEnergy, }: GetTronContractCallNetworkFeeArgs) => Promise<string>;
+export {};

package/dist/cjs/utils/tron/getTronNetworkFeeCryptoBaseUnit.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTronContractCallNetworkFeeCryptoBaseUnit = exports.getTronContractCallFallbackFeeCryptoBaseUnit = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const unchained_client_1 = require("@shapeshiftoss/unchained-client");
+const utils_1 = require("@shapeshiftoss/utils");
+// A measured worst-case energy under the adapter's margin, at live prices
+const getTronContractCallFallbackFeeCryptoBaseUnit = async ({ adapter, energy, bandwidthBytes, contractAddress, fullEnergyOnShareLookupFailure = false, }) => {
+    const { httpProvider } = adapter;
+    const [{ energyPrice, bandwidthPrice }, share] = await Promise.all([
+        httpProvider.getChainPrices(),
+        contractAddress
+            ? httpProvider.getContractEnergyShare(chain_adapters_1.tron.toTronBase58(contractAddress)).catch(error => {
+                if (!fullEnergyOnShareLookupFailure)
+                    throw error;
+                return undefined;
+            })
+            : undefined,
+    ]);
+    const callerEnergy = share ? unchained_client_1.tron.getCallerEnergy(Number(energy), share) : energy;
+    return (0, utils_1.bn)(callerEnergy)
+        .times(chain_adapters_1.tron.TRON_ENERGY_SAFETY_MARGIN)
+        .times(energyPrice)
+        .plus((0, utils_1.bn)(bandwidthBytes).times(bandwidthPrice))
+        .toFixed(0);
+};
+exports.getTronContractCallFallbackFeeCryptoBaseUnit = getTronContractCallFallbackFeeCryptoBaseUnit;
+// Quote arm: a funded token sell that reverts for want of its allowance prices the measured worst case, anything else throws
+const getTronContractCallNetworkFeeCryptoBaseUnit = async ({ adapter, transactionData, from, sellAsset, sellAmountCryptoBaseUnit, spenderAddress, fallbackEnergy, }) => {
+    const { to, value, data } = transactionData;
+    try {
+        const { fast } = await adapter.getFeeData({
+            to,
+            value,
+            chainSpecific: { from, data, requireEnergyShare: true },
+        });
+        return fast.txFee;
+    }
+    catch (error) {
+        if (!(0, utils_1.isToken)(sellAsset.assetId))
+            throw error;
+        const contractAddress = (0, caip_1.fromAssetId)(sellAsset.assetId).assetReference;
+        const { httpProvider } = adapter;
+        const [allowance, balance] = await Promise.all([
+            httpProvider.getTrc20Allowance({
+                contractAddress,
+                owner: from,
+                spender: chain_adapters_1.tron.toTronBase58(spenderAddress),
+            }),
+            httpProvider.getTrc20Balance({ contractAddress, address: from }),
+        ]);
+        const sellAmount = BigInt(sellAmountCryptoBaseUnit);
+        if (BigInt(allowance) >= sellAmount || BigInt(balance) < sellAmount)
+            throw error;
+        return (0, exports.getTronContractCallFallbackFeeCryptoBaseUnit)({
+            adapter,
+            energy: fallbackEnergy,
+            bandwidthBytes: chain_adapters_1.tron.getTronContractCallBandwidthBytes(data),
+            contractAddress: to,
+        });
+    }
+};
+exports.getTronContractCallNetworkFeeCryptoBaseUnit = getTronContractCallNetworkFeeCryptoBaseUnit;

package/dist/cjs/utils/tron/getTronNetworkFeeCryptoBaseUnit.test.d.ts

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

package/dist/cjs/utils/tron/getTronNetworkFeeCryptoBaseUnit.test.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const caip_1 = require("@shapeshiftoss/caip");
+const vitest_1 = require("vitest");
+const assets_1 = require("../test-data/assets");
+const getTronNetworkFeeCryptoBaseUnit_1 = require("./getTronNetworkFeeCryptoBaseUnit");
+const USDT = 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t';
+const TRX = { ...assets_1.ETH, assetId: `${caip_1.tronChainId}/slip44:195`, chainId: caip_1.tronChainId };
+const USDT_TRON = { ...assets_1.ETH, assetId: `${caip_1.tronChainId}/trc20:${USDT}`, chainId: caip_1.tronChainId };
+const FROM = 'TT2T17KZhoDu47i2E4FWxfG79zdkEWkU9N';
+const SPENDER_HEX = '4107a39ae4c49dee86e892450b20881f32cd5d500d';
+const SPENDER = 'TAfbit1ENsRmtZbPQfYU3srURpfYuWYS7K';
+const transactionData = { to: SPENDER, data: '0x2213bc0b', value: '0' };
+const makeAdapter = ({ allowance = '0', balance = '100000000', simulation = 'ok', } = {}) => {
+    const getFeeData = simulation === 'ok'
+        ? vitest_1.vi.fn().mockResolvedValue({ fast: { txFee: '9000000' } })
+        : vitest_1.vi.fn().mockRejectedValue(new Error('REVERT opcode executed'));
+    const getTrc20Allowance = vitest_1.vi.fn().mockResolvedValue(allowance);
+    const getTrc20Balance = vitest_1.vi.fn().mockResolvedValue(balance);
+    const getContractEnergyShare = vitest_1.vi.fn().mockResolvedValue({
+        callerPercent: 100,
+        originEnergyLimit: 0,
+        originEnergyAvailable: 0,
+    });
+    const adapter = {
+        getFeeData,
+        httpProvider: {
+            getTrc20Allowance,
+            getTrc20Balance,
+            getContractEnergyShare,
+            getChainPrices: () => Promise.resolve({ energyPrice: 100, bandwidthPrice: 1000 }),
+        },
+    };
+    return {
+        adapter: adapter,
+        getFeeData,
+        getTrc20Allowance,
+        getTrc20Balance,
+        getContractEnergyShare,
+    };
+};
+const baseArgs = {
+    transactionData,
+    from: FROM,
+    sellAmountCryptoBaseUnit: '100000000',
+    spenderAddress: SPENDER_HEX,
+    fallbackEnergy: '400000',
+};
+// 400000 energy * 1.2 margin * 100 sun + (4 calldata + 279 envelope) bytes * 1000 sun
+const FALLBACK_FEE = '48283000';
+(0, vitest_1.describe)('getTronContractCallFallbackFeeCryptoBaseUnit', () => {
+    (0, vitest_1.it)('prices the energy under the adapter margin at live prices plus the bandwidth', async () => {
+        const { adapter, getContractEnergyShare } = makeAdapter();
+        (0, vitest_1.expect)(await (0, getTronNetworkFeeCryptoBaseUnit_1.getTronContractCallFallbackFeeCryptoBaseUnit)({
+            adapter,
+            energy: '400000',
+            bandwidthBytes: 283,
+        })).toBe(FALLBACK_FEE);
+        (0, vitest_1.expect)(getContractEnergyShare).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('bills the caller only their share of a contract whose deployer covers the rest', async () => {
+        const { adapter, getContractEnergyShare } = makeAdapter();
+        getContractEnergyShare.mockResolvedValue({
+            callerPercent: 5,
+            originEnergyLimit: 10_000_000,
+            originEnergyAvailable: 5_000_000,
+        });
+        // 20000 caller energy * 1.2 margin * 100 sun + 283 bytes * 1000 sun
+        (0, vitest_1.expect)(await (0, getTronNetworkFeeCryptoBaseUnit_1.getTronContractCallFallbackFeeCryptoBaseUnit)({
+            adapter,
+            energy: '400000',
+            bandwidthBytes: 283,
+            contractAddress: SPENDER,
+        })).toBe('2683000');
+        (0, vitest_1.expect)(getContractEnergyShare).toHaveBeenCalledWith(SPENDER);
+    });
+});
+(0, vitest_1.describe)('getTronContractCallFallbackFeeCryptoBaseUnit share lookup failure', () => {
+    (0, vitest_1.it)('rejects by default', async () => {
+        const { adapter, getContractEnergyShare } = makeAdapter();
+        getContractEnergyShare.mockRejectedValue(new Error('429'));
+        await (0, vitest_1.expect)((0, getTronNetworkFeeCryptoBaseUnit_1.getTronContractCallFallbackFeeCryptoBaseUnit)({
+            adapter,
+            energy: '400000',
+            bandwidthBytes: 283,
+            contractAddress: SPENDER,
+        })).rejects.toThrow('429');
+    });
+    (0, vitest_1.it)('prices the caller in full when the caller opts in', async () => {
+        const { adapter, getContractEnergyShare } = makeAdapter();
+        getContractEnergyShare.mockRejectedValue(new Error('429'));
+        (0, vitest_1.expect)(await (0, getTronNetworkFeeCryptoBaseUnit_1.getTronContractCallFallbackFeeCryptoBaseUnit)({
+            adapter,
+            energy: '400000',
+            bandwidthBytes: 283,
+            contractAddress: SPENDER,
+            fullEnergyOnShareLookupFailure: true,
+        })).toBe(FALLBACK_FEE);
+    });
+});
+(0, vitest_1.describe)('getTronContractCallNetworkFeeCryptoBaseUnit', () => {
+    (0, vitest_1.it)('prices a successful simulation without reading the allowance', async () => {
+        const { adapter, getFeeData, getTrc20Allowance } = makeAdapter();
+        const actual = await (0, getTronNetworkFeeCryptoBaseUnit_1.getTronContractCallNetworkFeeCryptoBaseUnit)({
+            ...baseArgs,
+            adapter,
+            sellAsset: USDT_TRON,
+        });
+        (0, vitest_1.expect)(actual).toBe('9000000');
+        (0, vitest_1.expect)(getFeeData).toHaveBeenCalledWith({
+            to: SPENDER,
+            value: '0',
+            chainSpecific: { from: FROM, data: '0x2213bc0b', requireEnergyShare: true },
+        });
+        (0, vitest_1.expect)(getTrc20Allowance).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('prices the measured worst case when a funded token sell reverts without its allowance', async () => {
+        const { adapter, getTrc20Allowance, getTrc20Balance, getContractEnergyShare } = makeAdapter({
+            simulation: 'revert',
+            allowance: '0',
+        });
+        const actual = await (0, getTronNetworkFeeCryptoBaseUnit_1.getTronContractCallNetworkFeeCryptoBaseUnit)({
+            ...baseArgs,
+            adapter,
+            sellAsset: USDT_TRON,
+        });
+        (0, vitest_1.expect)(actual).toBe(FALLBACK_FEE);
+        (0, vitest_1.expect)(getTrc20Allowance).toHaveBeenCalledWith({
+            contractAddress: USDT,
+            owner: FROM,
+            spender: SPENDER,
+        });
+        (0, vitest_1.expect)(getTrc20Balance).toHaveBeenCalledWith({ contractAddress: USDT, address: FROM });
+        (0, vitest_1.expect)(getContractEnergyShare).toHaveBeenCalledWith(SPENDER);
+    });
+    (0, vitest_1.it)('fails the quote rather than guessing when the share lookup fails', async () => {
+        const { adapter, getContractEnergyShare } = makeAdapter({
+            simulation: 'revert',
+            allowance: '0',
+        });
+        getContractEnergyShare.mockRejectedValue(new Error('429'));
+        await (0, vitest_1.expect)((0, getTronNetworkFeeCryptoBaseUnit_1.getTronContractCallNetworkFeeCryptoBaseUnit)({ ...baseArgs, adapter, sellAsset: USDT_TRON })).rejects.toThrow('429');
+    });
+    (0, vitest_1.it)('throws when a token sell reverts with a sufficient allowance', async () => {
+        const { adapter } = makeAdapter({ simulation: 'revert', allowance: '100000000' });
+        await (0, vitest_1.expect)((0, getTronNetworkFeeCryptoBaseUnit_1.getTronContractCallNetworkFeeCryptoBaseUnit)({ ...baseArgs, adapter, sellAsset: USDT_TRON })).rejects.toThrow('REVERT opcode executed');
+    });
+    (0, vitest_1.it)('throws when the token balance cannot cover the sell', async () => {
+        const { adapter } = makeAdapter({ simulation: 'revert', allowance: '0', balance: '1' });
+        await (0, vitest_1.expect)((0, getTronNetworkFeeCryptoBaseUnit_1.getTronContractCallNetworkFeeCryptoBaseUnit)({ ...baseArgs, adapter, sellAsset: USDT_TRON })).rejects.toThrow('REVERT opcode executed');
+    });
+    (0, vitest_1.it)('throws when a native sell reverts', async () => {
+        const { adapter, getTrc20Allowance } = makeAdapter({ simulation: 'revert' });
+        await (0, vitest_1.expect)((0, getTronNetworkFeeCryptoBaseUnit_1.getTronContractCallNetworkFeeCryptoBaseUnit)({ ...baseArgs, adapter, sellAsset: TRX })).rejects.toThrow('REVERT opcode executed');
+        (0, vitest_1.expect)(getTrc20Allowance).not.toHaveBeenCalled();
+    });
+});

package/dist/cjs/utils/tron/getUnsignedTronTransaction.d.ts

@@ -1,2 +1,3 @@
+import { tron } from '@shapeshiftoss/chain-adapters';
 import type { GetUnsignedTronTransactionArgs } from '../../types';
-export declare const getUnsignedTronTransaction: ({ stepIndex, tradeQuote, from, assertGetTronChainAdapter, }: GetUnsignedTronTransactionArgs) => Promise<import("packages/chain-adapters/src/tron").TronSignTx>;
+export declare const getUnsignedTronTransaction: ({ stepIndex, tradeQuote, from, assertGetTronChainAdapter, }: GetUnsignedTronTransactionArgs) => Promise<tron.TronSignTx>;

package/dist/cjs/utils/tron/getUnsignedTronTransaction.js

@@ -1,64 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getUnsignedTronTransaction = void 0;
-const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
 const utils_1 = require("@shapeshiftoss/utils");
-const tronweb_1 = require("tronweb");
 const utils_2 = require("../../utils");
 const getUnsignedTronTransaction = ({ stepIndex, tradeQuote, from, assertGetTronChainAdapter, }) => {
     if (!(0, utils_2.isExecutableTradeQuote)(tradeQuote))
-        throw new Error('Unable to execute a trade rate quote');
+        throw new Error('Unable to execute a trade rate');
     const step = (0, utils_2.getExecutableTradeStep)(tradeQuote, stepIndex);
-    const { accountNumber, sellAsset, relayTransactionMetadata, butterSwapTransactionMetadata } = step;
+    const { accountNumber, sellAsset, transactionData, feeData } = step;
+    if (transactionData?.type !== 'tron')
+        throw new Error('Missing tron transactionData');
     const adapter = assertGetTronChainAdapter(sellAsset.chainId);
-    if (butterSwapTransactionMetadata) {
-        const { to, data, method, args, value: butterValue } = butterSwapTransactionMetadata;
-        if (!to)
-            throw new Error('Missing Butter swap contract address');
-        if (!data)
-            throw new Error('Missing Butter swap transaction data');
-        // Use Butter's value field which includes swap fees for same-chain swaps
-        // For native TRX sells, also include the sell amount
-        const isNativeTron = sellAsset.assetId === caip_1.tronAssetId;
-        const value = isNativeTron ? step.sellAmountIncludingProtocolFeesCryptoBaseUnit : butterValue;
-        return adapter.buildCustomApiTx({
-            from,
-            to,
-            accountNumber,
-            data,
-            value,
-            method,
-            args,
-        });
-    }
-    if (relayTransactionMetadata?.data) {
-        if (!relayTransactionMetadata.to) {
-            throw new Error('Missing Relay transaction destination address');
-        }
-        const to = tronweb_1.TronWeb.address.fromHex(relayTransactionMetadata.to);
-        const isNativeTron = sellAsset.assetId === caip_1.tronAssetId;
-        const value = isNativeTron ? step.sellAmountIncludingProtocolFeesCryptoBaseUnit : '0';
-        return adapter.buildCustomApiTx({
-            from,
-            to,
-            accountNumber,
-            data: relayTransactionMetadata.data,
-            value,
-        });
-    }
-    const nearIntentsDepositAddress = step.swapperMetadata?.name === 'nearIntents' ? step.swapperMetadata.depositAddress : undefined;
-    const to = relayTransactionMetadata?.to ?? nearIntentsDepositAddress;
-    if (!to)
-        throw new Error('Missing transaction destination address');
-    const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
-    const contractAddress = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
+    const { to, value, data, memo } = transactionData;
+    const feeLimit = chain_adapters_1.tron.getTronFeeLimit(feeData.networkFeeCryptoBaseUnit);
+    if (data)
+        return adapter.buildCustomApiTx({ from, to, accountNumber, data, value, feeLimit });
     return adapter.buildSendApiTransaction({
-        to,
         from,
-        value,
+        to,
         accountNumber,
+        value,
         chainSpecific: {
-            contractAddress,
+            contractAddress: (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId),
+            memo,
+            feeLimit,
         },
     });
 };

package/dist/cjs/utils/tron/getUnsignedTronTransaction.test.d.ts

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