@shapeshiftoss/swapper 20.2.0 → 20.4.0

package/dist/esm/swappers/RelaySwapper/utils/getRelayStepData.test.js

@@ -0,0 +1,137 @@
+import { tronChainId } from '@shapeshiftoss/caip';
+import { describe, expect, it, vi } from 'vitest';
+import { ETH } from '../../../utils/test-data/assets.js';
+import { getRelayStepData } from './getRelayStepData.js';
+import { getRelayAllowanceContract } from './helpers.js';
+const USDT = 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t';
+const TRX = { ...ETH, assetId: `${tronChainId}/slip44:195`, chainId: tronChainId };
+const USDT_TRON = { ...ETH, assetId: `${tronChainId}/trc20:${USDT}`, chainId: tronChainId };
+const FROM = 'TT2T17KZhoDu47i2E4FWxfG79zdkEWkU9N';
+const DEPOSITOR_HEX = '41f0623e1012177482912fb057e44e1a9769b1f588';
+const DEPOSITOR = 'TXtEs6t2oUWQsNos7m68gbHdE9Q5n6x2oN';
+const tronItem = {
+    type: 'TriggerSmartContract',
+    parameter: { contract_address: DEPOSITOR_HEX, data: '49290c1c', call_value: 50000000 },
+};
+const tronAdapter = ({ txFee = '9000000', allowance = '0' } = {}) => ({
+    getFeeData: vi.fn().mockResolvedValue({ fast: { txFee } }),
+    httpProvider: {
+        getChainPrices: () => Promise.resolve({ energyPrice: 100, bandwidthPrice: 1000 }),
+        getTrc20Allowance: vi.fn().mockResolvedValue(allowance),
+        getTrc20Balance: vi.fn().mockResolvedValue('100000000'),
+        getContractEnergyShare: vi.fn().mockResolvedValue({
+            callerPercent: 100,
+            originEnergyLimit: 0,
+            originEnergyAvailable: 0,
+        }),
+    },
+});
+const makeDeps = (tron) => ({ assertGetTronChainAdapter: () => tron });
+const baseArgs = {
+    data: tronItem,
+    sellAsset: TRX,
+    sellAmountCryptoBaseUnit: '50000000',
+    spenderAddress: '',
+    orderId: undefined,
+    xpub: undefined,
+    fallbackNetworkFeeCryptoBaseUnit: '6100715',
+};
+describe('getRelayAllowanceContract', () => {
+    it('returns the tron depositor as relay gives it', () => {
+        expect(getRelayAllowanceContract(tronItem)).toBe(DEPOSITOR_HEX);
+    });
+});
+describe('getRelayStepData', () => {
+    describe('tron', () => {
+        it('carries the depositor call as transactionData and simulates it', async () => {
+            const adapter = tronAdapter();
+            const actual = await getRelayStepData({
+                ...baseArgs,
+                type: 'quote',
+                input: {},
+                from: FROM,
+                deps: makeDeps(adapter),
+            });
+            const transactionData = {
+                type: 'tron',
+                to: DEPOSITOR_HEX,
+                data: '49290c1c',
+                value: '50000000',
+            };
+            expect(actual.unwrap()).toEqual({ transactionData, networkFeeCryptoBaseUnit: '9000000' });
+            expect(adapter.getFeeData).toHaveBeenCalledWith({
+                to: DEPOSITOR_HEX,
+                value: '50000000',
+                chainSpecific: { from: FROM, data: '49290c1c', requireEnergyShare: true },
+            });
+        });
+        it('fails a native quote when the simulation fails', async () => {
+            const adapter = tronAdapter();
+            adapter.getFeeData.mockRejectedValue(new Error('REVERT opcode executed'));
+            const actual = await getRelayStepData({
+                ...baseArgs,
+                type: 'quote',
+                input: {},
+                from: FROM,
+                deps: makeDeps(adapter),
+            });
+            expect(actual.isErr()).toBe(true);
+        });
+        it('prices the measured worst case when a token allowance is not granted yet', async () => {
+            const adapter = tronAdapter({ allowance: '0' });
+            adapter.getFeeData.mockRejectedValue(new Error('REVERT opcode executed'));
+            const actual = await getRelayStepData({
+                ...baseArgs,
+                data: { type: 'TriggerSmartContract', parameter: { ...tronItem.parameter, call_value: 0 } },
+                sellAsset: USDT_TRON,
+                type: 'quote',
+                input: {},
+                from: FROM,
+                deps: makeDeps(adapter),
+            });
+            // 100000 energy * 1.2 margin * 100 sun + (4 calldata + 279 envelope) bytes * 1000 sun
+            expect(actual.unwrap().networkFeeCryptoBaseUnit).toBe('12283000');
+            expect(adapter.httpProvider.getTrc20Allowance).toHaveBeenCalledWith({
+                contractAddress: USDT,
+                owner: FROM,
+                spender: DEPOSITOR,
+            });
+        });
+        it('prices a rate from the measured deposit', async () => {
+            const adapter = tronAdapter();
+            const actual = await getRelayStepData({
+                ...baseArgs,
+                type: 'rate',
+                input: {},
+                from: FROM,
+                deps: makeDeps(adapter),
+            });
+            // 100000 energy * 1.2 margin * 100 sun + (4 calldata + 279 envelope) bytes * 1000 sun
+            expect(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '12283000' });
+            expect(adapter.httpProvider.getContractEnergyShare).toHaveBeenCalledWith(DEPOSITOR);
+        });
+        it('falls back to the relay fee when the measured deposit cannot be priced', async () => {
+            const adapter = tronAdapter();
+            adapter.httpProvider.getChainPrices = () => Promise.reject(new Error('429'));
+            const actual = await getRelayStepData({
+                ...baseArgs,
+                type: 'rate',
+                input: {},
+                from: FROM,
+                deps: makeDeps(adapter),
+            });
+            expect(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '6100715' });
+        });
+        it('fails to build without the depositor call', async () => {
+            const actual = await getRelayStepData({
+                ...baseArgs,
+                data: { type: 'TriggerSmartContract', parameter: {} },
+                type: 'quote',
+                input: {},
+                from: FROM,
+                deps: makeDeps(tronAdapter()),
+            });
+            expect(actual.isErr()).toBe(true);
+        });
+    });
+});

package/dist/esm/swappers/RelaySwapper/utils/getRelayTradeContext.d.ts

@@ -13,6 +13,7 @@ type RelayTradeContext = {
     }[];
     stepDataArgs: Omit<GetRelayStepDataArgs, 'type' | 'input' | 'data' | 'spenderAddress'>;
     relayId: string;
+    deadline: number | undefined;
 };
 export declare const getRelayTradeContext: ({ input, deps, relayChainMap, }: {
     input: RelayTradeQuoteInput | RelayTradeRateInput | RelayExactOutputTradeQuoteInput | RelayExactOutputTradeRateInput;

package/dist/esm/swappers/RelaySwapper/utils/getRelayTradeContext.js

@@ -7,7 +7,7 @@ import { zeroAddress } from 'viem';
 import { MixPanelEvent, SwapperName, TradeQuoteError } from '../../../types.js';
 import { getInputOutputRate, makeSwapErrorRight } from '../../../utils/index.js';
 import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
-import { getTradeAmount, isNativeEvmAsset } from '../../../utils/helpers.js';
+import { getTradeAmount, isNativeEvmAsset, normalizeEpochToMs } from '../../../utils/helpers.js';
 import { MAXIMUM_SUPPORTED_RELAY_STEPS, relayErrorCodeToTradeQuoteError } from '../constant.js';
 import { getRelayAssetAddress } from '../utils/getRelayAssetAddress.js';
 import { relayTokenToAsset } from '../utils/relayTokenToAsset.js';
@@ -258,6 +258,9 @@ export const getRelayTradeContext = async ({ input, deps, relayChainMap, }) => {
         .plus(appFeesBaseUnit)
         .toFixed();
     const relayId = quote.steps[0].requestId;
+    // Only cross-chain (protocol v2) orders carry an expiry; past it the solver submits a no-fill refund
+    const orderDeadline = quote.protocol?.v2?.orderData?.output?.deadline;
+    const deadline = orderDeadline === undefined ? undefined : normalizeEpochToMs(orderDeadline);
     const relayStepInputs = swapSteps.map(step => {
         const data = step.items?.[0]?.data;
         return { data, allowanceContract: getRelayAllowanceContract(data) };
@@ -301,6 +304,7 @@ export const getRelayTradeContext = async ({ input, deps, relayChainMap, }) => {
             ...appFeesAsProtocolFee,
         },
         relayStepInputs,
+        deadline,
         stepDataArgs: {
             sellAsset,
             sellAmountCryptoBaseUnit,

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

@@ -51,8 +51,7 @@ export const resolveRelayAddresses = ({ input, sellChainId, buyChainId, }) => {
     const refundTo = input.sendAddress ?? getRelayDefaultUserAddress(sellChainId);
     return { sendAddress, recipient, refundTo };
 };
-// The spender to approve: EVM routes approve the router (data.to); Tron approves the token contract;
-// UTXO/Solana need no allowance. Derived from the provider route, not the built transactionData.
+// The spender to approve is the call target: EVM data.to, tron the depositor; UTXO/Solana need none
 export const getRelayAllowanceContract = (data) => {
     if (!data)
         return '';

package/dist/esm/swappers/RelaySwapper/utils/relayStatus.js

@@ -20,13 +20,13 @@ export const relayStatusToTxStatus = (status) => {
 };
 // Relay index requests by origin tx hash, resolving a swap we hold no relayId for
 export const fetchRelayRequestByTxHash = async (txHash, config) => {
-    const maybeResponse = await relayService.get(`${config.VITE_RELAY_API_URL}/requests/v2?hash=${txHash}`, getRelayRequestConfig(config));
+    const maybeResponse = await relayService.get(`${config.VITE_RELAY_API_URL}/requests/v3?depositTxHash=${txHash}`, getRelayRequestConfig(config));
     // Match the origin tx ourselves rather than trusting the listing to have filtered on it
-    return maybeResponse.map(({ data }) => data.requests?.find(({ data: request }) => request?.inTxs?.some(({ hash }) => hash?.toLowerCase() === txHash.toLowerCase())));
+    return maybeResponse.map(({ data }) => data.requests?.find(({ data: request }) => request?.inTxs?.some(({ txHash: hash }) => hash?.toLowerCase() === txHash.toLowerCase())));
 };
 export const getRelayRequestFailureMessage = (request) => {
     const { failReason, refundFailReason } = request.data ?? {};
-    // Relay report 'N/A' rather than omitting the reason when there isn't one
+    // Relay can report 'N/A' rather than null when there isn't one
     const reason = [failReason, refundFailReason].find(value => value && value !== 'N/A');
     return reason ?? 'Bridge failed';
 };

package/dist/esm/swappers/RelaySwapper/utils/relayTokenToAssetId.js

@@ -1,6 +1,6 @@
 import { ASSET_NAMESPACE, ASSET_REFERENCE, btcChainId, CHAIN_REFERENCE, fromChainId, solanaChainId, toAssetId, tronChainId, } from '@shapeshiftoss/caip';
-import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
-import { DEFAULT_RELAY_EVM_TOKEN_ADDRESS, RELAY_BTC_TOKEN_ADDRESS, RELAY_SOLANA_TOKEN_ADDRESS, RELAY_TRON_TOKEN_ADDRESS, relayChainIdToChainId, } from '../constant.js';
+import { isEvmChainId, tron } from '@shapeshiftoss/chain-adapters';
+import { DEFAULT_RELAY_EVM_TOKEN_ADDRESS, RELAY_BTC_TOKEN_ADDRESS, RELAY_SOLANA_TOKEN_ADDRESS, relayChainIdToChainId, } from '../constant.js';
 export const relayTokenToAssetId = (relayToken) => {
     const chainId = relayChainIdToChainId[relayToken.chainId];
     const { chainReference } = fromChainId(chainId);
@@ -15,7 +15,7 @@ export const relayTokenToAssetId = (relayToken) => {
             return relayToken.address === RELAY_SOLANA_TOKEN_ADDRESS;
         }
         if (chainId === tronChainId) {
-            return relayToken.address === RELAY_TRON_TOKEN_ADDRESS;
+            return relayToken.address === tron.TRON_ZERO_ADDRESS;
         }
         return false;
     })();

package/dist/esm/swappers/RelaySwapper/utils/types.d.ts

@@ -3,22 +3,18 @@ export type RelayTradeQuoteInput = GetEvmTradeQuoteInput | GetUtxoTradeQuoteInpu
 export type RelayTradeRateInput = GetEvmTradeRateInput | GetUtxoTradeRateInput | GetSolanaTradeRateInput | GetTronTradeRateInput;
 export type RelayExactOutputTradeQuoteInput = WithExactBuyAmount<RelayTradeQuoteInput>;
 export type RelayExactOutputTradeRateInput = WithExactBuyAmount<RelayTradeRateInput>;
-export type RelayTransactionMetadata = {
-    to?: string;
-    data?: string;
-};
 export type RelayMetadata = {
     name: 'relay';
     relayId: string;
     data?: string;
 };
 export type RelayRequestTransaction = {
-    hash?: string;
+    txHash?: string;
     chainId?: number;
 };
 export type RelayRequestData = {
-    failReason?: string;
-    refundFailReason?: string;
+    failReason?: string | null;
+    refundFailReason?: string | null;
     inTxs?: RelayRequestTransaction[];
     outTxs?: RelayRequestTransaction[];
 };
@@ -114,6 +110,7 @@ export type RelayQuoteTronItemData = {
         owner_address?: string;
         contract_address?: string;
         data?: string;
+        call_value?: number;
     };
 };
 export type RelayQuoteItem = {
@@ -124,9 +121,14 @@ export type RelayQuoteStep = {
     requestId: string;
     items?: RelayQuoteItem[];
 };
+export type RelayOrderData = {
+    output?: {
+        deadline?: number;
+    };
+};
 export type RelayProtocolV2 = {
     orderId: string | undefined;
-    orderData?: unknown;
+    orderData?: RelayOrderData;
     paymentDetails?: {
         chainId: string;
         depository: string;

package/dist/esm/swappers/SunioSwapper/endpoints.js

@@ -1,75 +1,15 @@
-import { tronAssetId, tronChainId } from '@shapeshiftoss/caip';
-import { toAddressNList } from '@shapeshiftoss/chain-adapters';
+import { tronChainId } from '@shapeshiftoss/caip';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
-import { TronWeb } from 'tronweb';
-import { createDefaultStatusResponse, getExecutableTradeStep, isExecutableTradeQuote, } from '../../utils/index.js';
+import { createDefaultStatusResponse } from '../../utils/index.js';
+import { getTronTransactionFees, getUnsignedTronTransaction } from '../../utils/tron/index.js';
 import { getSunioTradeQuote } from './getSunioTradeQuote/getSunioTradeQuote.js';
 import { getSunioTradeRate } from './getSunioTradeRate/getSunioTradeRate.js';
-import { buildSwapExactInputParameters, SUNIO_SWAP_EXACT_INPUT_SELECTOR, } from './utils/buildSwapContractCall.js';
-import { buildSwapRouteParameters } from './utils/buildSwapRouteParameters.js';
-import { SUNIO_SMART_ROUTER_CONTRACT } from './utils/constants.js';
-import { getSunioTransactionFees } from './utils/getSunioTransactionFees.js';
 const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 export const sunioApi = {
     getTradeQuote: (input, deps) => getSunioTradeQuote(input, deps),
     getTradeRate: (input, deps) => getSunioTradeRate(input, deps),
-    getUnsignedTronTransaction: async (args) => {
-        const { tradeQuote, stepIndex, from, slippageTolerancePercentageDecimal, assertGetTronChainAdapter, config, } = args;
-        if (!isExecutableTradeQuote(tradeQuote)) {
-            throw new Error('Unable to execute a trade rate quote');
-        }
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const adapter = assertGetTronChainAdapter(tronChainId);
-        const sunioTransactionData = step.sunioTransactionData;
-        if (!sunioTransactionData)
-            throw new Error('[Sun.io] Missing transaction data in quote');
-        const rpcUrl = adapter.httpProvider.getRpcUrl();
-        const tronWeb = new TronWeb({
-            fullHost: rpcUrl,
-            headers: config.VITE_TRON_GRID_API_KEY
-                ? { 'TRON-PRO-API-KEY': config.VITE_TRON_GRID_API_KEY }
-                : {},
-        });
-        const routeParams = buildSwapRouteParameters(sunioTransactionData.route, step.sellAmountIncludingProtocolFeesCryptoBaseUnit, step.buyAmountAfterFeesCryptoBaseUnit, tradeQuote.receiveAddress, slippageTolerancePercentageDecimal);
-        const parameters = buildSwapExactInputParameters(routeParams);
-        const isSellingNativeTrx = step.sellAsset.assetId === tronAssetId;
-        const callValue = isSellingNativeTrx
-            ? Number(step.sellAmountIncludingProtocolFeesCryptoBaseUnit)
-            : 0;
-        const options = {
-            feeLimit: 100_000_000,
-            callValue,
-        };
-        const txData = await tronWeb.transactionBuilder.triggerSmartContract(SUNIO_SMART_ROUTER_CONTRACT, SUNIO_SWAP_EXACT_INPUT_SELECTOR, options, parameters, from);
-        if (!txData.result || !txData.result.result) {
-            throw new Error('[Sun.io] Failed to build swap transaction');
-        }
-        const transaction = txData.transaction;
-        const rawDataHex = typeof transaction.raw_data_hex === 'string'
-            ? transaction.raw_data_hex
-            : Buffer.isBuffer(transaction.raw_data_hex)
-                ? transaction.raw_data_hex.toString('hex')
-                : Array.isArray(transaction.raw_data_hex)
-                    ? Buffer.from(transaction.raw_data_hex).toString('hex')
-                    : (() => {
-                        throw new Error(`Unexpected raw_data_hex type: ${typeof transaction.raw_data_hex}`);
-                    })();
-        if (!/^[0-9a-fA-F]+$/.test(rawDataHex)) {
-            throw new Error(`Invalid raw_data_hex format: ${rawDataHex.slice(0, 100)}`);
-        }
-        const accountNumber = step.accountNumber;
-        if (accountNumber === undefined) {
-            throw new Error('[Sun.io] accountNumber is required for execution');
-        }
-        const bip44Params = adapter.getBip44Params({ accountNumber });
-        const addressNList = toAddressNList(bip44Params);
-        return {
-            addressNList,
-            rawDataHex,
-            transaction,
-        };
-    },
-    getTronTransactionFees: getSunioTransactionFees,
+    getUnsignedTronTransaction,
+    getTronTransactionFees,
     checkTradeStatus: async ({ txHash, assertGetTronChainAdapter }) => {
         try {
             // Wait for TronGrid indexing to avoid false "REVERT"

package/dist/esm/swappers/SunioSwapper/getSunioTradeQuote/getSunioTradeQuote.js

@@ -1,6 +1,5 @@
 import { Err, Ok } from '@sniptt/monads';
 import { assertQuoteAddresses } from '../../../utils/index.js';
-import { FALLBACK_QUOTE_DEADLINE_MS } from '../../../utils/helpers.js';
 import { getSunioStepData } from '../utils/getSunioStepData.js';
 import { getSunioTradeContext } from '../utils/getSunioTradeContext.js';
 export const getSunioTradeQuote = async (input, deps) => {
@@ -21,17 +20,17 @@ export const getSunioTradeQuote = async (input, deps) => {
     });
     if (maybeStepData.isErr())
         return Err(maybeStepData.unwrapErr());
-    const { networkFeeCryptoBaseUnit, sunioTransactionData } = maybeStepData.unwrap();
+    const { networkFeeCryptoBaseUnit, transactionData, deadline } = maybeStepData.unwrap();
     const tradeQuote = {
         ...tradeCommon,
         quoteOrRate: 'quote',
-        deadline: Date.now() + FALLBACK_QUOTE_DEADLINE_MS,
+        deadline,
         receiveAddress,
         steps: [
             {
                 ...stepCommon,
                 accountNumber,
-                sunioTransactionData,
+                transactionData,
                 feeData: { networkFeeCryptoBaseUnit, protocolFees },
             },
         ],

package/dist/esm/swappers/SunioSwapper/getSunioTradeRate/getSunioTradeRate.js

@@ -7,7 +7,13 @@ export const getSunioTradeRate = async (input, deps) => {
     if (maybeContext.isErr())
         return Err(maybeContext.unwrapErr());
     const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
-    const maybeStepData = await getSunioStepData({ ...stepDataArgs, type: 'rate', input });
+    // Sun.io is tron-only, so the receive address is also the seller's account to simulate from
+    const maybeStepData = await getSunioStepData({
+        ...stepDataArgs,
+        type: 'rate',
+        input,
+        from: input.sendAddress ?? receiveAddress,
+    });
     if (maybeStepData.isErr())
         return Err(maybeStepData.unwrapErr());
     const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();

package/dist/esm/swappers/SunioSwapper/types.d.ts

@@ -16,9 +16,6 @@ export type SunioRoute = {
     poolVersions: string[];
     stepAmountsOut: string[];
 };
-export type SunioTransactionData = {
-    route: SunioRoute;
-};
 export type SunioQuoteResponse = {
     code: number;
     message: string;

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

@@ -1,6 +1,11 @@
-import type { SwapRouteParameters } from './buildSwapRouteParameters.js';
-export declare const SUNIO_SWAP_EXACT_INPUT_SELECTOR = "swapExactInput(address[],string[],uint256[],uint24[],(uint256,uint256,address,uint256))";
-export declare const buildSwapExactInputParameters: (routeParams: SwapRouteParameters) => {
-    type: string;
-    value: unknown;
-}[];
+import type { SunioRoute } from '../types.js';
+type BuildSunioSwapCalldataArgs = {
+    route: SunioRoute;
+    sellAmountCryptoBaseUnit: string;
+    minBuyAmountCryptoBaseUnit: string;
+    recipient: string;
+    slippageTolerancePercentageDecimal: string;
+    deadline: number;
+};
+export declare const buildSunioSwapCalldata: ({ route, sellAmountCryptoBaseUnit, minBuyAmountCryptoBaseUnit, recipient, slippageTolerancePercentageDecimal, deadline, }: BuildSunioSwapCalldataArgs) => string;
+export {};

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

@@ -1,29 +1,32 @@
-import { TronWeb } from 'tronweb';
-export const SUNIO_SWAP_EXACT_INPUT_SELECTOR = 'swapExactInput(address[],string[],uint256[],uint24[],(uint256,uint256,address,uint256))';
-const convertAddressesToEvmFormat = (value) => {
-    if (Array.isArray(value)) {
-        return value.map(v => convertAddressesToEvmFormat(v));
-    }
-    if (typeof value === 'string' && value.startsWith('T') && TronWeb.isAddress(value)) {
-        const hex = TronWeb.address.toHex(value);
-        return hex.replace(/^41/, '0x');
-    }
-    return value;
+import { tron } from '@shapeshiftoss/chain-adapters';
+import { bn } from '@shapeshiftoss/utils';
+import { encodeFunctionData, parseAbiItem } from 'viem';
+const SUNIO_SWAP_EXACT_INPUT_ABI = parseAbiItem('function swapExactInput(address[], string[], uint256[], uint24[], (uint256,uint256,address,uint256))');
+// SmartExchangeRouter swapExactInput calldata - the TVM ABI is EVM-compatible, addresses as 20-byte bodies
+export const buildSunioSwapCalldata = ({ route, sellAmountCryptoBaseUnit, minBuyAmountCryptoBaseUnit, recipient, slippageTolerancePercentageDecimal, deadline, }) => {
+    const amountOutMin = bn(minBuyAmountCryptoBaseUnit)
+        .times(bn(1).minus(slippageTolerancePercentageDecimal))
+        .toFixed(0);
+    // The SmartExchangeRouter expects sum(versionLen) === path.length: the first pool segment consumes
+    // 2 tokens (input + output) and each subsequent pool reuses the previous output, consuming 1 new
+    // token. Relies on the Sun.io API returning poolVersions per-hop (poolVersions.length ===
+    // tokens.length - 1), which it does.
+    const versionLen = route.poolVersions.map((_, index) => (index === 0 ? 2n : 1n));
+    const swapData = [
+        BigInt(sellAmountCryptoBaseUnit),
+        BigInt(amountOutMin),
+        tron.toTronHex(recipient),
+        BigInt(Math.floor(deadline / 1000)),
+    ];
+    return encodeFunctionData({
+        abi: [SUNIO_SWAP_EXACT_INPUT_ABI],
+        functionName: 'swapExactInput',
+        args: [
+            route.tokens.map(tron.toTronHex),
+            route.poolVersions,
+            versionLen,
+            route.poolFees.map(Number),
+            swapData,
+        ],
+    });
 };
-// Parameter list for the SmartExchangeRouter swapExactInput call, shared between fee
-// estimation and execution so both encode the call identically.
-export const buildSwapExactInputParameters = (routeParams) => [
-    { type: 'address[]', value: routeParams.path },
-    { type: 'string[]', value: routeParams.poolVersion },
-    { type: 'uint256[]', value: routeParams.versionLen },
-    { type: 'uint24[]', value: routeParams.fees },
-    {
-        type: 'tuple(uint256,uint256,address,uint256)',
-        value: convertAddressesToEvmFormat([
-            routeParams.swapData.amountIn,
-            routeParams.swapData.amountOutMin,
-            routeParams.swapData.recipient,
-            routeParams.swapData.deadline,
-        ]),
-    },
-];

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

@@ -2,7 +2,7 @@ export declare const SUNIO_SUPPORTED_CHAIN_IDS: readonly [import("@shapeshiftoss
 export declare const SUNIO_API_BASE_URL = "https://rot.endjgfsv.link";
 export declare const SUNIO_SMART_ROUTER_CONTRACT: "TCFNp179Lg46D16zKoumd4Poa2WFFdtqYj";
 export declare const DEFAULT_SLIPPAGE_PERCENTAGE = "0.005";
-export declare const SUNIO_FALLBACK_SWAP_ENERGY_NATIVE = 215000;
-export declare const SUNIO_FALLBACK_SWAP_ENERGY_TRC20 = 375000;
+export declare const SUNIO_SWAP_DEADLINE_MS: number;
+export declare const SUNIO_FALLBACK_SWAP_ENERGY_NATIVE = "250000";
+export declare const SUNIO_FALLBACK_SWAP_ENERGY_TRC20 = "480000";
 export declare const SUNIO_DEX_TYPES: "PSM,CURVE,CURVE_COMBINATION,WTRX,SUNSWAP_V1,SUNSWAP_V2,SUNSWAP_V3";
-export declare const SUNIO_TRON_NATIVE_ADDRESS: "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb";

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

@@ -8,12 +8,8 @@ export const SUNIO_API_BASE_URL = 'https://rot.endjgfsv.link';
 // This is the current mainnet router that sun.io's frontend uses
 export const SUNIO_SMART_ROUTER_CONTRACT = 'TCFNp179Lg46D16zKoumd4Poa2WFFdtqYj';
 export const DEFAULT_SLIPPAGE_PERCENTAGE = '0.005';
-// Energy fallbacks for when we can't simulate a swap (no address, or the simulation reverts
-// pre-approval for TRC20 sells). Set to observed average energy so the 1.2x margin applied at
-// estimate time lifts them to cover the worst case (native ~245k, TRC20 ~415k due to the extra
-// transferFrom token pull) without double-counting safety.
-export const SUNIO_FALLBACK_SWAP_ENERGY_NATIVE = 215_000;
-export const SUNIO_FALLBACK_SWAP_ENERGY_TRC20 = 375_000;
+export const SUNIO_SWAP_DEADLINE_MS = 20 * 60 * 1000;
+// p90 router energy on mainnet, for rates that can't simulate and token quotes without their allowance
+export const SUNIO_FALLBACK_SWAP_ENERGY_NATIVE = '250000';
+export const SUNIO_FALLBACK_SWAP_ENERGY_TRC20 = '480000';
 export const SUNIO_DEX_TYPES = 'PSM,CURVE,CURVE_COMBINATION,WTRX,SUNSWAP_V1,SUNSWAP_V2,SUNSWAP_V3';
-// Native TRX token address (used when assetId is not a TRC-20 token)
-export const SUNIO_TRON_NATIVE_ADDRESS = 'T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb';

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

@@ -1,17 +1,22 @@
 import type { Result } from '@sniptt/monads';
-import type { StepDataArgs, SwapErrorRight } from '../../../types.js';
-import type { SunioRoute, SunioTransactionData } from '../types.js';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.js';
+import type { SunioRoute } from '../types.js';
 type BaseArgs = {
     route: SunioRoute;
     sellAmountCryptoBaseUnit: string;
+    buyAmountCryptoBaseUnit: string;
 };
 export type GetSunioStepDataArgs = StepDataArgs<BaseArgs>;
+type TronTxBuildData = Extract<TxBuildData, {
+    type: 'tron';
+}>;
 type SunioRateStepData = {
     networkFeeCryptoBaseUnit: string | undefined;
 };
 type SunioQuoteStepData = {
+    transactionData: TronTxBuildData;
     networkFeeCryptoBaseUnit: string;
-    sunioTransactionData: SunioTransactionData;
+    deadline: number;
 };
 export declare function getSunioStepData(args: Extract<GetSunioStepDataArgs, {
     type: 'rate';

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

@@ -1,35 +1,69 @@
-import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
+import { tronAssetId } from '@shapeshiftoss/caip';
+import { tron } from '@shapeshiftoss/chain-adapters';
 import { Err, Ok } from '@sniptt/monads';
 import { makeNetworkFeeEstimationFailedErr } from '../../../utils/index.js';
-import { estimateSunioNetworkFeeCryptoBaseUnit } from './estimateSunioNetworkFee.js';
+import { getTronContractCallFallbackFeeCryptoBaseUnit, getTronContractCallNetworkFeeCryptoBaseUnit, TRON_PLACEHOLDER_ADDRESS, } from '../../../utils/tron/index.js';
+import { buildSunioSwapCalldata } from './buildSwapContractCall.js';
+import { DEFAULT_SLIPPAGE_PERCENTAGE, SUNIO_FALLBACK_SWAP_ENERGY_NATIVE, SUNIO_FALLBACK_SWAP_ENERGY_TRC20, SUNIO_SMART_ROUTER_CONTRACT, SUNIO_SWAP_DEADLINE_MS, } from './constants.js';
 export async function getSunioStepData(args) {
-    const { type, route, sellAsset, sellAmountCryptoBaseUnit, from, input, deps } = args;
-    const estimateArgs = {
-        rpcUrl: deps.config.VITE_TRON_NODE_URL,
-        apiKey: deps.config.VITE_TRON_GRID_API_KEY,
-        route,
-        sellAmountCryptoBaseUnit,
-        isSellingNativeTrx: !contractAddressOrUndefined(sellAsset.assetId),
-        address: from,
-        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
-    };
+    const { type, route, sellAsset, sellAmountCryptoBaseUnit, buyAmountCryptoBaseUnit, from, input } = args;
+    const adapter = args.deps.assertGetTronChainAdapter(sellAsset.chainId);
+    const isNativeSell = sellAsset.assetId === tronAssetId;
+    const fallbackEnergy = isNativeSell
+        ? SUNIO_FALLBACK_SWAP_ENERGY_NATIVE
+        : SUNIO_FALLBACK_SWAP_ENERGY_TRC20;
+    // The router reverts past this, so the quote expires with it
+    const deadline = Date.now() + SUNIO_SWAP_DEADLINE_MS;
+    const buildCall = (recipient) => ({
+        to: SUNIO_SMART_ROUTER_CONTRACT,
+        value: isNativeSell ? sellAmountCryptoBaseUnit : '0',
+        data: buildSunioSwapCalldata({
+            route,
+            sellAmountCryptoBaseUnit,
+            minBuyAmountCryptoBaseUnit: buyAmountCryptoBaseUnit,
+            recipient,
+            slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal ?? DEFAULT_SLIPPAGE_PERCENTAGE,
+            deadline,
+        }),
+    });
     if (type === 'rate') {
         const networkFeeCryptoBaseUnit = await (async () => {
             try {
-                return await estimateSunioNetworkFeeCryptoBaseUnit(estimateArgs);
+                if (from) {
+                    const { to, value, data } = buildCall(from);
+                    const { fast } = await adapter.getFeeData({ to, value, chainSpecific: { from, data } });
+                    return fast.txFee;
+                }
             }
-            catch {
-                return undefined;
+            catch { }
+            try {
+                return await getTronContractCallFallbackFeeCryptoBaseUnit({
+                    adapter,
+                    energy: fallbackEnergy,
+                    bandwidthBytes: tron.getTronContractCallBandwidthBytes(buildCall(from ?? TRON_PLACEHOLDER_ADDRESS).data),
+                    contractAddress: SUNIO_SMART_ROUTER_CONTRACT,
+                    fullEnergyOnShareLookupFailure: true,
+                });
             }
+            catch { }
         })();
         const stepData = { networkFeeCryptoBaseUnit };
         return Ok(stepData);
     }
+    const call = buildCall(input.receiveAddress);
     try {
-        const networkFeeCryptoBaseUnit = await estimateSunioNetworkFeeCryptoBaseUnit(estimateArgs);
         const stepData = {
-            networkFeeCryptoBaseUnit,
-            sunioTransactionData: { route },
+            transactionData: { type: 'tron', ...call },
+            networkFeeCryptoBaseUnit: await getTronContractCallNetworkFeeCryptoBaseUnit({
+                adapter,
+                transactionData: call,
+                from,
+                sellAsset,
+                sellAmountCryptoBaseUnit,
+                spenderAddress: SUNIO_SMART_ROUTER_CONTRACT,
+                fallbackEnergy,
+            }),
+            deadline,
         };
         return Ok(stepData);
     }

package/dist/esm/swappers/SunioSwapper/utils/getSunioStepData.test.d.ts

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