@shapeshiftoss/swapper 20.2.0 → 20.4.0

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

@@ -0,0 +1,162 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { BigNumber, bn } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import axios from 'axios';
+import { getAddress, isAddress, isAddressEqual, zeroAddress } from 'viem';
+import { TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
+import { isNativeEvmAsset } from '../../../utils/helpers.js';
+import { FYND_CHAINS, FYND_CLIENT_FEE_SHARE, FYND_CLIENT_FEE_SIGNATURE_BYTES } from './constants.js';
+const isFyndSupportedChainId = (chainId) => chainId in FYND_CHAINS;
+// Protocol ids look like uniswap_v3, vm:balancer_v2 or fallback:rfq:bebop
+const formatFyndProtocol = (protocol) => protocol
+    .slice(protocol.lastIndexOf(':') + 1)
+    .split('_')
+    .map(word => /^v\d+$/.test(word) ? word.toUpperCase() : word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+// The native_wrapper hop is only the WETH wrap/unwrap around the real venues
+export const getFyndRouteProtocols = (swaps) => {
+    const venues = (swaps ?? [])
+        .map(swap => swap.protocol)
+        .filter(protocol => !protocol.endsWith('native_wrapper'));
+    return [...new Set(venues)].map(formatFyndProtocol);
+};
+export const getFyndClientFeeBps = (affiliateBps) => bn(affiliateBps).div(FYND_CLIENT_FEE_SHARE).integerValue(BigNumber.ROUND_CEIL).toNumber();
+export const convertAssetIdToFyndToken = (assetId) => {
+    if (isNativeEvmAsset(assetId))
+        return zeroAddress;
+    return getAddress(fromAssetId(assetId).assetReference);
+};
+export const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    if (sellAsset.chainId !== buyAsset.chainId) {
+        return Err(makeSwapErrorRight({
+            message: 'Fynd does not support cross-chain trades',
+            code: TradeQuoteError.CrossChainNotSupported,
+        }));
+    }
+    if (!isFyndSupportedChainId(sellAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: 'Fynd only supports configured EVM chains',
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    return Ok(sellAsset.chainId);
+};
+const getFyndStatusError = (status, detail) => {
+    const code = (() => {
+        switch (status.toLowerCase()) {
+            case 'no_route_found':
+            case 'insufficient_liquidity':
+                return TradeQuoteError.NoRouteFound;
+            case 'timeout':
+                return TradeQuoteError.Timeout;
+            default:
+                return TradeQuoteError.QueryFailed;
+        }
+    })();
+    return makeSwapErrorRight({
+        message: `Fynd quote failed: ${status}${detail ? ` (${detail})` : ''}`,
+        code,
+    });
+};
+const isFyndErrorResponse = (value) => typeof value === 'object' &&
+    value !== null &&
+    'error' in value &&
+    typeof value.error === 'string' &&
+    'code' in value &&
+    typeof value.code === 'string';
+export const getFyndRequestError = (error) => {
+    const { cause } = error;
+    if (!axios.isAxiosError(cause))
+        return error;
+    if (cause.response?.status === 429) {
+        return makeSwapErrorRight({
+            message: 'Fynd rate limit exceeded',
+            code: TradeQuoteError.RateLimitExceeded,
+        });
+    }
+    const body = cause.response?.data;
+    if (isFyndErrorResponse(body))
+        return getFyndStatusError(body.code, body.error);
+    return makeSwapErrorRight({
+        message: `Fynd request failed with status ${cause.response?.status}`,
+        code: TradeQuoteError.QueryFailed,
+        cause,
+    });
+};
+const invalidResponse = (message, details) => makeSwapErrorRight({ message, details, code: TradeQuoteError.InvalidResponse });
+const getQuoteError = (quote, { chainId, sellAsset, sellAmountCryptoBaseUnit, slippageTolerancePercentageDecimal, clientFeeBps, }) => {
+    const { transaction, fee_breakdown: fees } = quote;
+    const pinnedRouter = FYND_CHAINS[chainId].routerAddress;
+    if (!isAddress(transaction.to, { strict: false }) ||
+        !isAddressEqual(transaction.to, pinnedRouter)) {
+        return invalidResponse(`Fynd router ${transaction.to} is not the pinned router ${pinnedRouter} for ${chainId}`);
+    }
+    if (!bn(quote.amount_in).eq(sellAmountCryptoBaseUnit)) {
+        return invalidResponse('Fynd quoted a different sell amount', {
+            amountIn: quote.amount_in,
+            sellAmountCryptoBaseUnit,
+        });
+    }
+    const expectedValue = isNativeEvmAsset(sellAsset.assetId) ? sellAmountCryptoBaseUnit : '0';
+    if (!bn(transaction.value).eq(expectedValue)) {
+        return invalidResponse('Fynd transaction value does not match the sell amount', {
+            value: transaction.value,
+            expectedValue,
+        });
+    }
+    // The router enforces min_amount_received, which may not be looser than the requested slippage
+    const netOutput = bn(quote.amount_out).minus(fees.router_fee).minus(fees.client_fee);
+    const outputFloor = netOutput
+        .times(bn(1).minus(slippageTolerancePercentageDecimal))
+        .integerValue(BigNumber.ROUND_DOWN);
+    if (bn(fees.min_amount_received).lt(outputFloor)) {
+        return invalidResponse('Fynd output floor is below the requested slippage', {
+            minAmountReceived: fees.min_amount_received,
+            outputFloor: outputFloor.toFixed(),
+            slippageTolerancePercentageDecimal,
+        });
+    }
+    if (clientFeeBps === 0) {
+        if (!bn(fees.client_fee).isZero()) {
+            return invalidResponse('Fynd returned an unexpected client fee', {
+                clientFee: fees.client_fee,
+            });
+        }
+        return;
+    }
+    // Our share of the gross client fee, allowing one unit of rounding
+    const minClientFee = bn(quote.amount_out)
+        .times(clientFeeBps)
+        .div(10_000)
+        .times(FYND_CLIENT_FEE_SHARE)
+        .integerValue(BigNumber.ROUND_DOWN)
+        .minus(1);
+    if (bn(fees.client_fee).lt(minClientFee)) {
+        return invalidResponse('Fynd client fee is below the requested share', {
+            clientFee: fees.client_fee,
+            amountOut: quote.amount_out,
+            clientFeeBps,
+        });
+    }
+    // The proxy patches the signature over Fynd's zeroed placeholder at the reported offset
+    const offset = transaction.client_fee_signature_offset;
+    const signature = typeof offset === 'number'
+        ? transaction.data.slice(2 + offset * 2, 2 + (offset + FYND_CLIENT_FEE_SIGNATURE_BYTES) * 2)
+        : '';
+    if (signature.length !== FYND_CLIENT_FEE_SIGNATURE_BYTES * 2 || /^0+$/.test(signature)) {
+        return invalidResponse('Fynd quote is not signed for the client fee', { offset });
+    }
+    if (!quote.client_fee_deadline) {
+        return invalidResponse('Fynd quote is missing its client fee deadline');
+    }
+};
+export const validateFyndQuoteResponse = (response, context) => {
+    const order = Array.isArray(response?.orders) ? response.orders[0] : undefined;
+    if (!order)
+        return Err(invalidResponse('Fynd returned no order'));
+    if (order.status !== 'success')
+        return Err(getFyndStatusError(order.status));
+    const error = getQuoteError(order, context);
+    return error ? Err(error) : Ok(order);
+};

package/dist/esm/swappers/FyndSwapper/utils/helpers.test.d.ts

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

package/dist/esm/swappers/FyndSwapper/utils/helpers.test.js

@@ -0,0 +1,99 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { describe, expect, it } from 'vitest';
+import { ETH, WETH } from '../../../utils/test-data/assets.js';
+import { FYND_CHAINS } from './constants.js';
+import { getFyndClientFeeBps, validateFyndQuoteResponse } from './helpers.js';
+describe('getFyndClientFeeBps', () => {
+    it.each([
+        ['nets the default fee after the 20% share', '60', 75],
+        ['rounds up so the net never falls short', '55', 69],
+        ['requests nothing for a fee-free swap', '0', 0],
+    ])('%s', (_label, affiliateBps, grossBps) => {
+        expect(getFyndClientFeeBps(affiliateBps)).toBe(grossBps);
+    });
+});
+describe('validateFyndQuoteResponse', () => {
+    const router = FYND_CHAINS['eip155:1'].routerAddress;
+    const unpinnedRouter = '0x1111111111111111111111111111111111111111';
+    const transaction = {
+        to: router,
+        value: '0',
+        data: '0x12345678',
+        client_fee_signature_offset: null,
+    };
+    const fees = { router_fee: '10', client_fee: '0', max_slippage: '4', min_amount_received: '986' };
+    const order = {
+        status: 'success',
+        amount_in: '1000',
+        amount_out: '1000',
+        gas_estimate: '21000',
+        transaction,
+        fee_breakdown: fees,
+    };
+    const context = {
+        chainId: KnownChainIds.EthereumMainnet,
+        sellAsset: WETH,
+        sellAmountCryptoBaseUnit: '1000',
+        slippageTolerancePercentageDecimal: '0.005',
+        clientFeeBps: 0,
+    };
+    const validate = (overrides, contextOverrides = {}) => validateFyndQuoteResponse({ orders: [{ ...order, ...overrides }] }, { ...context, ...contextOverrides });
+    it('accepts a quote that matches the request', () => {
+        expect(validate({}).isOk()).toBe(true);
+    });
+    it.each([
+        ['an unpinned router', { transaction: { ...transaction, to: unpinnedRouter } }],
+        ['a different sell amount', { amount_in: '999' }],
+        ['native value on a token sell', { transaction: { ...transaction, value: '1' } }],
+        [
+            'an output floor looser than the slippage',
+            { fee_breakdown: { ...fees, min_amount_received: '984' } },
+        ],
+        ['a client fee we did not request', { fee_breakdown: { ...fees, client_fee: '1' } }],
+    ])('rejects %s', (_label, overrides) => {
+        expect(validate(overrides).isErr()).toBe(true);
+    });
+    it('binds native transaction value to the requested sell amount', () => {
+        expect(validate({}, { sellAsset: ETH }).isErr()).toBe(true);
+        expect(validate({ transaction: { ...transaction, value: '1000' } }, { sellAsset: ETH }).isOk()).toBe(true);
+    });
+    it('maps a missing route to NoRouteFound', () => {
+        const result = validateFyndQuoteResponse({ orders: [{ status: 'no_route_found' }] }, context);
+        expect(result.unwrapErr().code).toBe('NoRouteFound');
+    });
+    describe('with a client fee', () => {
+        const feeContext = { clientFeeBps: 75 };
+        const feeOrder = {
+            transaction: {
+                ...transaction,
+                data: `0x12345678${'ab'.repeat(65)}`,
+                client_fee_signature_offset: 4,
+            },
+            fee_breakdown: {
+                router_fee: '2',
+                client_fee: '6',
+                max_slippage: '4',
+                min_amount_received: '988',
+            },
+            client_fee_deadline: 1_900_000_000,
+        };
+        it('accepts a signed quote carrying our share of the fee', () => {
+            expect(validate(feeOrder, feeContext).isOk()).toBe(true);
+        });
+        it.each([
+            [
+                'a fee below our share',
+                {
+                    fee_breakdown: { ...feeOrder.fee_breakdown, client_fee: '4', min_amount_received: '990' },
+                },
+            ],
+            [
+                'an unsigned placeholder',
+                { transaction: { ...feeOrder.transaction, data: `0x12345678${'00'.repeat(65)}` } },
+            ],
+            ['a missing deadline', { client_fee_deadline: null }],
+        ])('rejects %s', (_label, overrides) => {
+            expect(validate({ ...feeOrder, ...overrides }, feeContext).isErr()).toBe(true);
+        });
+    });
+});

package/dist/esm/swappers/MayachainSwapper/generated/generatedTradableAssetMap.json

@@ -4,7 +4,6 @@
     "ARB.ETH": "eip155:42161/slip44:60",
     "ARB.GLD-0XAFD091F140C21770F4E5D53D26B2859AE97555AA": "eip155:42161/erc20:0xafd091f140c21770f4e5d53d26b2859ae97555aa",
     "ARB.LEO-0X93864D81175095DD93360FFA2A529B8642F76A6E": "eip155:42161/erc20:0x93864d81175095dd93360ffa2a529b8642f76a6e",
-    "ARB.LINK-0XF97F4DF75117A78C1A5A0DBB814AF92458539FB4": "eip155:42161/erc20:0xf97f4df75117a78c1a5a0dbb814af92458539fb4",
     "ARB.PEPE-0X25D887CE7A35172C62FEBFD67A1856F20FAEBB00": "eip155:42161/erc20:0x25d887ce7a35172c62febfd67a1856f20faebb00",
     "ARB.TGT-0X429FED88F10285E61B12BDF00848315FBDFCC341": "eip155:42161/erc20:0x429fed88f10285e61b12bdf00848315fbdfcc341",
     "ARB.USDC-0XAF88D065E77C8CC2239327C5EDB3A432268E5831": "eip155:42161/erc20:0xaf88d065e77c8cc2239327c5edb3a432268e5831",

package/dist/esm/swappers/NearIntentsSwapper/constants.d.ts

@@ -2,3 +2,4 @@ export declare const ONE_CLICK_BASE_URL = "https://1click.chaindefuser.com";
 export declare const DEFAULT_SLIPPAGE_BPS = 50;
 export declare const DEFAULT_QUOTE_DEADLINE_MS: number;
 export declare const UTXO_QUOTE_DEADLINE_MS: number;
+export declare const APP_FEE_SPLIT_MULTIPLIER = 2;

package/dist/esm/swappers/NearIntentsSwapper/constants.js

@@ -3,3 +3,5 @@ export const DEFAULT_SLIPPAGE_BPS = 50;
 // 1Click refunds a deposit it cannot settle by the requested deadline, and prices a quote the same at any length
 export const DEFAULT_QUOTE_DEADLINE_MS = 60 * 60 * 1000;
 export const UTXO_QUOTE_DEADLINE_MS = 4 * 60 * 60 * 1000;
+// 1Click pays half of the requested appFee to its own account, so request double to receive affiliateBps
+export const APP_FEE_SPLIT_MULTIPLIER = 2;

package/dist/esm/swappers/NearIntentsSwapper/utils/getNearIntentsStepData.js

@@ -142,12 +142,17 @@ export async function getNearIntentsStepData(args) {
                 const { fast } = await deps.assertGetTronChainAdapter(sellAsset.chainId).getFeeData({
                     to: depositAddress,
                     value: sellAmountCryptoBaseUnit,
-                    chainSpecific: {
-                        from,
-                        contractAddress: contractAddressOrUndefined(sellAsset.assetId),
-                    },
+                    chainSpecific: { from, contractAddress, requireEnergyShare: type === 'quote' },
                 });
-                const stepData = { networkFeeCryptoBaseUnit: fast.txFee };
+                const networkFeeCryptoBaseUnit = fast.txFee;
+                if (type === 'rate') {
+                    const stepData = { networkFeeCryptoBaseUnit };
+                    return Ok(stepData);
+                }
+                const stepData = {
+                    transactionData: { type: 'tron', to: depositAddress, value: sellAmountCryptoBaseUnit },
+                    networkFeeCryptoBaseUnit,
+                };
                 return Ok(stepData);
             }
             case CHAIN_NAMESPACE.Sui: {

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

@@ -5,7 +5,7 @@ import { Err, Ok } from '@sniptt/monads';
 import { zeroAddress } from 'viem';
 import { TradeQuoteError } from '../../../types.js';
 import { createTradeAmountTooSmallErr, makeSwapErrorRight } from '../../../utils/index.js';
-import { DEFAULT_QUOTE_DEADLINE_MS, DEFAULT_SLIPPAGE_BPS, UTXO_QUOTE_DEADLINE_MS, } from '../constants.js';
+import { APP_FEE_SPLIT_MULTIPLIER, DEFAULT_QUOTE_DEADLINE_MS, DEFAULT_SLIPPAGE_BPS, UTXO_QUOTE_DEADLINE_MS, } from '../constants.js';
 import { chainIdToNearIntentsChain, QuoteRequest } from '../types.js';
 import { ApiError, OneClickService } from './oneClickService.js';
 const getTokensWithRetry = async () => {
@@ -149,7 +149,7 @@ export const buildNearIntentsQuoteRequest = ({ originAsset, destinationAsset, am
         appFees: [
             {
                 recipient: DAO_TREASURY_NEAR,
-                fee: Number(affiliateBps),
+                fee: Number(affiliateBps) * APP_FEE_SPLIT_MULTIPLIER,
             },
         ],
     };

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

@@ -59,7 +59,7 @@ export const portalsApi = {
                 const txStatus = relayTxStatus === TxStatus.Unknown ? TxStatus.Pending : relayTxStatus;
                 return {
                     status: txStatus,
-                    buyTxHash: relayRequest.data?.outTxs?.[0]?.hash,
+                    buyTxHash: relayRequest.data?.outTxs?.[0]?.txHash,
                     message: txStatus === TxStatus.Failed
                         ? getRelayRequestFailureMessage(relayRequest)
                         : txStatus === TxStatus.Confirmed
@@ -68,6 +68,9 @@ export const portalsApi = {
                 };
             }
         }
+        else {
+            console.error('Failed to fetch relay request:', relayResult.unwrapErr());
+        }
         const axelarscanResult = await fetchAxelarscanBridgeStatus(txHash);
         if (axelarscanResult.isOk()) {
             const bridgeStatus = axelarscanResult.unwrap();

package/dist/esm/swappers/PortalsSwapper/getPortalsTradeQuote/getPortalsTradeQuote.js

@@ -2,7 +2,7 @@ import { BigNumber, bn } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { TradeQuoteError } from '../../../types.js';
 import { assertQuoteAddresses, makeSwapErrorRight, makeTradeStepBuildFailedErr, } from '../../../utils/index.js';
-import { FALLBACK_QUOTE_DEADLINE_MS, getTreasuryAddressFromChainId, normalizeEpochToMs, } from '../../../utils/helpers.js';
+import { getTreasuryAddressFromChainId, normalizeEpochToMs } from '../../../utils/helpers.js';
 import { fetchPortalsTradeOrder, PortalsError } from '../utils/fetchPortalsTradeOrder.js';
 import { getPortalsStepData } from '../utils/getPortalsStepData.js';
 import { getPortalsTradeContext } from '../utils/getPortalsTradeContext.js';
@@ -138,7 +138,7 @@ export const getPortalsTradeQuote = async (input, deps) => {
     const tradeQuote = {
         ...tradeCommon,
         quoteOrRate: 'quote',
-        deadline: expiryMs ?? Date.now() + FALLBACK_QUOTE_DEADLINE_MS,
+        deadline: expiryMs,
         receiveAddress,
         steps: [
             {

package/dist/esm/swappers/RelaySwapper/constant.d.ts

@@ -14,8 +14,8 @@ export declare const relayChainIdToChainId: import("lodash").Dictionary<string>;
 export declare const DEFAULT_RELAY_EVM_TOKEN_ADDRESS: "0x0000000000000000000000000000000000000000";
 export declare const RELAY_BTC_TOKEN_ADDRESS = "bc1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqmql8k8";
 export declare const RELAY_SOLANA_TOKEN_ADDRESS = "11111111111111111111111111111111";
-export declare const RELAY_TRON_TOKEN_ADDRESS = "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb";
 export declare const DEFAULT_RELAY_EVM_USER_ADDRESS = "0x000000000000000000000000000000000000dead";
+export declare const RELAY_TRON_FALLBACK_DEPOSIT_ENERGY = "100000";
 export declare const DEFAULT_RELAY_BTC_USER_ADDRESS = "bc1q4vxn43l44h30nkluqfxd9eckf45vr2awz38lwa";
 export declare const DEFAULT_RELAY_SOLANA_USER_ADDRESS = "CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn7X957YwNr";
 export declare const DEFAULT_RELAY_TRON_USER_ADDRESS = "TLsV52sRDL79HXGGm9yzwKibb6BeruhUzy";

package/dist/esm/swappers/RelaySwapper/constant.js

@@ -58,8 +58,9 @@ export const relayChainIdToChainId = invert(chainIdToRelayChainId);
 export const DEFAULT_RELAY_EVM_TOKEN_ADDRESS = zeroAddress;
 export const RELAY_BTC_TOKEN_ADDRESS = 'bc1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqmql8k8';
 export const RELAY_SOLANA_TOKEN_ADDRESS = '11111111111111111111111111111111';
-export const RELAY_TRON_TOKEN_ADDRESS = 'T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb';
 export const DEFAULT_RELAY_EVM_USER_ADDRESS = '0x000000000000000000000000000000000000dead';
+// depositor energy for a TRC20 deposit measured on mainnet, for token quotes without their allowance
+export const RELAY_TRON_FALLBACK_DEPOSIT_ENERGY = '100000';
 export const DEFAULT_RELAY_BTC_USER_ADDRESS = 'bc1q4vxn43l44h30nkluqfxd9eckf45vr2awz38lwa';
 export const DEFAULT_RELAY_SOLANA_USER_ADDRESS = 'CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn7X957YwNr';
 export const DEFAULT_RELAY_TRON_USER_ADDRESS = 'TLsV52sRDL79HXGGm9yzwKibb6BeruhUzy';

package/dist/esm/swappers/RelaySwapper/getTradeQuote/getTradeQuote.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 { getRelayStepData } from '../utils/getRelayStepData.js';
 import { getRelayTradeContext } from '../utils/getRelayTradeContext.js';
 const getQuote = async (input, deps, relayChainMap) => {
@@ -12,7 +11,7 @@ const getQuote = async (input, deps, relayChainMap) => {
     const maybeContext = await getRelayTradeContext({ input, deps, relayChainMap });
     if (maybeContext.isErr())
         return Err(maybeContext.unwrapErr());
-    const { tradeCommon, stepCommon, protocolFees, relayStepInputs, stepDataArgs, relayId } = maybeContext.unwrap();
+    const { tradeCommon, stepCommon, protocolFees, relayStepInputs, stepDataArgs, relayId, deadline, } = maybeContext.unwrap();
     const stepResults = await Promise.all(relayStepInputs.map(async ({ data, allowanceContract }) => {
         const maybeStepData = await getRelayStepData({
             ...stepDataArgs,
@@ -21,12 +20,11 @@ const getQuote = async (input, deps, relayChainMap) => {
             type: 'quote',
             input,
         });
-        return maybeStepData.map(({ transactionData, relayTransactionMetadata, networkFeeCryptoBaseUnit, }) => ({
+        return maybeStepData.map(({ transactionData, networkFeeCryptoBaseUnit }) => ({
             ...stepCommon,
             accountNumber,
             allowanceContract,
             transactionData,
-            relayTransactionMetadata,
             swapperMetadata: {
                 name: 'relay',
                 relayId,
@@ -43,7 +41,7 @@ const getQuote = async (input, deps, relayChainMap) => {
     const tradeQuote = {
         ...tradeCommon,
         quoteOrRate: 'quote',
-        deadline: Date.now() + FALLBACK_QUOTE_DEADLINE_MS,
+        deadline,
         receiveAddress,
         steps,
     };

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

@@ -1,13 +1,14 @@
 import { btcAssetId, fromAssetId, isAssetReference, solAssetId, tronAssetId, } from '@shapeshiftoss/caip';
+import { tron } from '@shapeshiftoss/chain-adapters';
 import { isNativeEvmAsset } from '../../../utils/helpers.js';
-import { DEFAULT_RELAY_EVM_TOKEN_ADDRESS, RELAY_BTC_TOKEN_ADDRESS, RELAY_SOLANA_TOKEN_ADDRESS, RELAY_TRON_TOKEN_ADDRESS, } from '../constant.js';
+import { DEFAULT_RELAY_EVM_TOKEN_ADDRESS, RELAY_BTC_TOKEN_ADDRESS, RELAY_SOLANA_TOKEN_ADDRESS, } from '../constant.js';
 export const getRelayAssetAddress = (asset) => {
     if (asset.assetId === btcAssetId)
         return RELAY_BTC_TOKEN_ADDRESS;
     if (asset.assetId === solAssetId)
         return RELAY_SOLANA_TOKEN_ADDRESS;
     if (asset.assetId === tronAssetId)
-        return RELAY_TRON_TOKEN_ADDRESS;
+        return tron.TRON_ZERO_ADDRESS;
     if (isNativeEvmAsset(asset.assetId))
         return DEFAULT_RELAY_EVM_TOKEN_ADDRESS;
     const { assetReference } = fromAssetId(asset.assetId);

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

@@ -1,7 +1,7 @@
 import type { Result } from '@sniptt/monads';
 import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.js';
 import type { SolanaComputeBudgetOptions } from '../../../utils/solana/index.js';
-import type { RelayQuoteItem, RelayTransactionMetadata } from './types.js';
+import type { RelayQuoteItem } from './types.js';
 export declare const RELAY_SOLANA_COMPUTE_BUDGET: SolanaComputeBudgetOptions;
 type BaseArgs = {
     data: RelayQuoteItem['data'];
@@ -15,8 +15,7 @@ type RelayRateStepData = {
     networkFeeCryptoBaseUnit: string;
 };
 type RelayQuoteStepData = {
-    transactionData?: TxBuildData;
-    relayTransactionMetadata?: RelayTransactionMetadata;
+    transactionData: TxBuildData;
     networkFeeCryptoBaseUnit: string;
 };
 export type GetRelayStepDataArgs = StepDataArgs<BaseArgs, {

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

@@ -1,10 +1,13 @@
 import { fromChainId } from '@shapeshiftoss/caip';
+import { tron } from '@shapeshiftoss/chain-adapters';
 import { bnOrZero, contractAddressOrUndefined, isToken } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { makeNetworkFeeEstimationFailedErr, makeTradeStepBuildFailedErr } from '../../../utils/index.js';
 import { getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
 import { getSolanaNetworkFeeCryptoBaseUnit, omitComputeBudgetInstructions, withComputeUnitLimit, } from '../../../utils/solana/index.js';
+import { getTronContractCallFallbackFeeCryptoBaseUnit, getTronContractCallNetworkFeeCryptoBaseUnit, } from '../../../utils/tron/index.js';
 import { getUtxoNetworkFeeCryptoBaseUnit } from '../../../utils/utxo/index.js';
+import { RELAY_TRON_FALLBACK_DEPOSIT_ENERGY } from '../constant.js';
 import { getRelayPsbtRelayer } from './getRelayPsbtRelayer.js';
 import { convertRelaySolanaInstruction } from './helpers.js';
 import { isRelayQuoteEvmItemData, isRelayQuoteSolanaItemData, isRelayQuoteTronItemData, isRelayQuoteUtxoItemData, } from './types.js';
@@ -169,25 +172,55 @@ export async function getRelayStepData({ data, sellAsset, sellAmountCryptoBaseUn
             return Err(makeNetworkFeeEstimationFailedErr('getRelayStepData', error));
         }
     }
+    // Native and token sells alike are a call into relay's depositor contract
     if (isRelayQuoteTronItemData(data)) {
-        const contractAddress = data.parameter?.contract_address;
-        const tronCallData = data.parameter?.data;
-        const isTronToken = isToken(sellAsset.assetId);
-        if (isTronToken && !contractAddress)
-            return Err(makeTradeStepBuildFailedErr('getRelayStepData'));
-        if (isTronToken && !tronCallData)
-            return Err(makeTradeStepBuildFailedErr('getRelayStepData'));
+        const { contract_address: contractAddress, data: callData, call_value: callValue, } = data.parameter ?? {};
         if (type === 'rate') {
+            // Relay's gas figure runs ~35% under the deposit's measured energy, so rates price the measured call
+            const networkFeeCryptoBaseUnit = await (async () => {
+                if (!contractAddress || !callData)
+                    return fallbackNetworkFeeCryptoBaseUnit;
+                try {
+                    return await getTronContractCallFallbackFeeCryptoBaseUnit({
+                        adapter: deps.assertGetTronChainAdapter(sellAsset.chainId),
+                        energy: RELAY_TRON_FALLBACK_DEPOSIT_ENERGY,
+                        bandwidthBytes: tron.getTronContractCallBandwidthBytes(callData),
+                        contractAddress,
+                    });
+                }
+                catch {
+                    return fallbackNetworkFeeCryptoBaseUnit;
+                }
+            })();
+            const stepData = { networkFeeCryptoBaseUnit };
+            return Ok(stepData);
+        }
+        if (!contractAddress || !callData)
+            return Err(makeTradeStepBuildFailedErr('getRelayStepData'));
+        const isNativeSell = !isToken(sellAsset.assetId);
+        const call = {
+            to: contractAddress,
+            data: callData,
+            value: String(callValue ?? (isNativeSell ? sellAmountCryptoBaseUnit : 0)),
+        };
+        try {
             const stepData = {
-                networkFeeCryptoBaseUnit: fallbackNetworkFeeCryptoBaseUnit,
+                transactionData: { type: 'tron', ...call },
+                networkFeeCryptoBaseUnit: await getTronContractCallNetworkFeeCryptoBaseUnit({
+                    adapter: deps.assertGetTronChainAdapter(sellAsset.chainId),
+                    transactionData: call,
+                    from,
+                    sellAsset,
+                    sellAmountCryptoBaseUnit,
+                    spenderAddress: contractAddress,
+                    fallbackEnergy: RELAY_TRON_FALLBACK_DEPOSIT_ENERGY,
+                }),
             };
             return Ok(stepData);
         }
-        const stepData = {
-            relayTransactionMetadata: { to: contractAddress, data: tronCallData },
-            networkFeeCryptoBaseUnit: fallbackNetworkFeeCryptoBaseUnit,
-        };
-        return Ok(stepData);
+        catch (error) {
+            return Err(makeNetworkFeeEstimationFailedErr('getRelayStepData', error));
+        }
     }
     return Err(makeTradeStepBuildFailedErr('getRelayStepData'));
 }

package/dist/esm/swappers/RelaySwapper/utils/getRelayStepData.test.d.ts

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