@shapeshiftoss/swapper 20.2.0 → 20.3.0

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

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

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

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

@@ -15,7 +15,6 @@ export * from './getThorL1TradeContexts.js';
 export * from './getThorL1TradeQuote.js';
 export * from './getThorL1TradeRate.js';
 export * from './getPoolDetails.js';
-export * as tron from './tron/index.js';
 export const getChainIdBySwapper = (swapperName) => {
     switch (swapperName) {
         case SwapperName.Thorchain:

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

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

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

@@ -0,0 +1,2 @@
+// An activated mainnet account, standing in as the sender/recipient for walletless rate estimation
+export const TRON_PLACEHOLDER_ADDRESS = 'TT2T17KZhoDu47i2E4FWxfG79zdkEWkU9N';

package/dist/esm/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.js';
+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/esm/utils/tron/getTronNetworkFeeCryptoBaseUnit.js

@@ -0,0 +1,59 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { tron } from '@shapeshiftoss/chain-adapters';
+import { tron as unchainedTron } from '@shapeshiftoss/unchained-client';
+import { bn, isToken } from '@shapeshiftoss/utils';
+// A measured worst-case energy under the adapter's margin, at live prices
+export const getTronContractCallFallbackFeeCryptoBaseUnit = async ({ adapter, energy, bandwidthBytes, contractAddress, fullEnergyOnShareLookupFailure = false, }) => {
+    const { httpProvider } = adapter;
+    const [{ energyPrice, bandwidthPrice }, share] = await Promise.all([
+        httpProvider.getChainPrices(),
+        contractAddress
+            ? httpProvider.getContractEnergyShare(tron.toTronBase58(contractAddress)).catch(error => {
+                if (!fullEnergyOnShareLookupFailure)
+                    throw error;
+                return undefined;
+            })
+            : undefined,
+    ]);
+    const callerEnergy = share ? unchainedTron.getCallerEnergy(Number(energy), share) : energy;
+    return bn(callerEnergy)
+        .times(tron.TRON_ENERGY_SAFETY_MARGIN)
+        .times(energyPrice)
+        .plus(bn(bandwidthBytes).times(bandwidthPrice))
+        .toFixed(0);
+};
+// Quote arm: a funded token sell that reverts for want of its allowance prices the measured worst case, anything else throws
+export 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 (!isToken(sellAsset.assetId))
+            throw error;
+        const contractAddress = fromAssetId(sellAsset.assetId).assetReference;
+        const { httpProvider } = adapter;
+        const [allowance, balance] = await Promise.all([
+            httpProvider.getTrc20Allowance({
+                contractAddress,
+                owner: from,
+                spender: tron.toTronBase58(spenderAddress),
+            }),
+            httpProvider.getTrc20Balance({ contractAddress, address: from }),
+        ]);
+        const sellAmount = BigInt(sellAmountCryptoBaseUnit);
+        if (BigInt(allowance) >= sellAmount || BigInt(balance) < sellAmount)
+            throw error;
+        return getTronContractCallFallbackFeeCryptoBaseUnit({
+            adapter,
+            energy: fallbackEnergy,
+            bandwidthBytes: tron.getTronContractCallBandwidthBytes(data),
+            contractAddress: to,
+        });
+    }
+};

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

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

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

@@ -0,0 +1,155 @@
+import { tronChainId } from '@shapeshiftoss/caip';
+import { describe, expect, it, vi } from 'vitest';
+import { ETH } from '../test-data/assets.js';
+import { getTronContractCallFallbackFeeCryptoBaseUnit, getTronContractCallNetworkFeeCryptoBaseUnit, } from './getTronNetworkFeeCryptoBaseUnit.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 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'
+        ? vi.fn().mockResolvedValue({ fast: { txFee: '9000000' } })
+        : vi.fn().mockRejectedValue(new Error('REVERT opcode executed'));
+    const getTrc20Allowance = vi.fn().mockResolvedValue(allowance);
+    const getTrc20Balance = vi.fn().mockResolvedValue(balance);
+    const getContractEnergyShare = 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';
+describe('getTronContractCallFallbackFeeCryptoBaseUnit', () => {
+    it('prices the energy under the adapter margin at live prices plus the bandwidth', async () => {
+        const { adapter, getContractEnergyShare } = makeAdapter();
+        expect(await getTronContractCallFallbackFeeCryptoBaseUnit({
+            adapter,
+            energy: '400000',
+            bandwidthBytes: 283,
+        })).toBe(FALLBACK_FEE);
+        expect(getContractEnergyShare).not.toHaveBeenCalled();
+    });
+    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
+        expect(await getTronContractCallFallbackFeeCryptoBaseUnit({
+            adapter,
+            energy: '400000',
+            bandwidthBytes: 283,
+            contractAddress: SPENDER,
+        })).toBe('2683000');
+        expect(getContractEnergyShare).toHaveBeenCalledWith(SPENDER);
+    });
+});
+describe('getTronContractCallFallbackFeeCryptoBaseUnit share lookup failure', () => {
+    it('rejects by default', async () => {
+        const { adapter, getContractEnergyShare } = makeAdapter();
+        getContractEnergyShare.mockRejectedValue(new Error('429'));
+        await expect(getTronContractCallFallbackFeeCryptoBaseUnit({
+            adapter,
+            energy: '400000',
+            bandwidthBytes: 283,
+            contractAddress: SPENDER,
+        })).rejects.toThrow('429');
+    });
+    it('prices the caller in full when the caller opts in', async () => {
+        const { adapter, getContractEnergyShare } = makeAdapter();
+        getContractEnergyShare.mockRejectedValue(new Error('429'));
+        expect(await getTronContractCallFallbackFeeCryptoBaseUnit({
+            adapter,
+            energy: '400000',
+            bandwidthBytes: 283,
+            contractAddress: SPENDER,
+            fullEnergyOnShareLookupFailure: true,
+        })).toBe(FALLBACK_FEE);
+    });
+});
+describe('getTronContractCallNetworkFeeCryptoBaseUnit', () => {
+    it('prices a successful simulation without reading the allowance', async () => {
+        const { adapter, getFeeData, getTrc20Allowance } = makeAdapter();
+        const actual = await getTronContractCallNetworkFeeCryptoBaseUnit({
+            ...baseArgs,
+            adapter,
+            sellAsset: USDT_TRON,
+        });
+        expect(actual).toBe('9000000');
+        expect(getFeeData).toHaveBeenCalledWith({
+            to: SPENDER,
+            value: '0',
+            chainSpecific: { from: FROM, data: '0x2213bc0b', requireEnergyShare: true },
+        });
+        expect(getTrc20Allowance).not.toHaveBeenCalled();
+    });
+    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 getTronContractCallNetworkFeeCryptoBaseUnit({
+            ...baseArgs,
+            adapter,
+            sellAsset: USDT_TRON,
+        });
+        expect(actual).toBe(FALLBACK_FEE);
+        expect(getTrc20Allowance).toHaveBeenCalledWith({
+            contractAddress: USDT,
+            owner: FROM,
+            spender: SPENDER,
+        });
+        expect(getTrc20Balance).toHaveBeenCalledWith({ contractAddress: USDT, address: FROM });
+        expect(getContractEnergyShare).toHaveBeenCalledWith(SPENDER);
+    });
+    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 expect(getTronContractCallNetworkFeeCryptoBaseUnit({ ...baseArgs, adapter, sellAsset: USDT_TRON })).rejects.toThrow('429');
+    });
+    it('throws when a token sell reverts with a sufficient allowance', async () => {
+        const { adapter } = makeAdapter({ simulation: 'revert', allowance: '100000000' });
+        await expect(getTronContractCallNetworkFeeCryptoBaseUnit({ ...baseArgs, adapter, sellAsset: USDT_TRON })).rejects.toThrow('REVERT opcode executed');
+    });
+    it('throws when the token balance cannot cover the sell', async () => {
+        const { adapter } = makeAdapter({ simulation: 'revert', allowance: '0', balance: '1' });
+        await expect(getTronContractCallNetworkFeeCryptoBaseUnit({ ...baseArgs, adapter, sellAsset: USDT_TRON })).rejects.toThrow('REVERT opcode executed');
+    });
+    it('throws when a native sell reverts', async () => {
+        const { adapter, getTrc20Allowance } = makeAdapter({ simulation: 'revert' });
+        await expect(getTronContractCallNetworkFeeCryptoBaseUnit({ ...baseArgs, adapter, sellAsset: TRX })).rejects.toThrow('REVERT opcode executed');
+        expect(getTrc20Allowance).not.toHaveBeenCalled();
+    });
+});

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

@@ -1,2 +1,3 @@
+import { tron } from '@shapeshiftoss/chain-adapters';
 import type { GetUnsignedTronTransactionArgs } from '../../types.js';
-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/esm/utils/tron/getUnsignedTronTransaction.js

@@ -1,61 +1,27 @@
-import { tronAssetId } from '@shapeshiftoss/caip';
+import { tron } from '@shapeshiftoss/chain-adapters';
 import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
-import { TronWeb } from 'tronweb';
 import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils/index.js';
 export const getUnsignedTronTransaction = ({ stepIndex, tradeQuote, from, assertGetTronChainAdapter, }) => {
     if (!isExecutableTradeQuote(tradeQuote))
-        throw new Error('Unable to execute a trade rate quote');
+        throw new Error('Unable to execute a trade rate');
     const step = 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 === 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.address.fromHex(relayTransactionMetadata.to);
-        const isNativeTron = sellAsset.assetId === 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 = contractAddressOrUndefined(sellAsset.assetId);
+    const { to, value, data, memo } = transactionData;
+    const feeLimit = 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: contractAddressOrUndefined(sellAsset.assetId),
+            memo,
+            feeLimit,
         },
     });
 };

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

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

package/dist/esm/utils/tron/getUnsignedTronTransaction.test.js

@@ -0,0 +1,74 @@
+import { tronChainId } from '@shapeshiftoss/caip';
+import { describe, expect, it, vi } from 'vitest';
+import { ETH } from '../test-data/assets.js';
+import { getUnsignedTronTransaction } from './getUnsignedTronTransaction.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 TO = 'TCFNp179Lg46D16zKoumd4Poa2WFFdtqYj';
+const makeArgs = (sellAsset, transactionData, feeData = {
+    networkFeeCryptoBaseUnit: '9000000',
+}) => {
+    const adapter = {
+        buildCustomApiTx: vi.fn().mockResolvedValue('custom'),
+        buildSendApiTransaction: vi.fn().mockResolvedValue('send'),
+    };
+    const tradeQuote = {
+        quoteOrRate: 'quote',
+        steps: [{ accountNumber: 0, sellAsset, transactionData, feeData }],
+    };
+    return {
+        adapter,
+        args: {
+            tradeQuote,
+            stepIndex: 0,
+            from: FROM,
+            assertGetTronChainAdapter: () => adapter,
+        },
+    };
+};
+describe('getUnsignedTronTransaction', () => {
+    it('builds a contract call when data is present', async () => {
+        const { adapter, args } = makeArgs(TRX, {
+            type: 'tron',
+            to: TO,
+            data: '0xdeadbeef',
+            value: '1',
+        });
+        expect(await getUnsignedTronTransaction(args)).toBe('custom');
+        expect(adapter.buildCustomApiTx).toHaveBeenCalledWith({
+            from: FROM,
+            to: TO,
+            accountNumber: 0,
+            data: '0xdeadbeef',
+            value: '1',
+            feeLimit: 27_000_000,
+        });
+    });
+    it('uses the standard fee limit when the step carries no estimate', async () => {
+        const { adapter, args } = makeArgs(TRX, { type: 'tron', to: TO, data: '0xdeadbeef', value: '1' }, { networkFeeCryptoBaseUnit: undefined });
+        await getUnsignedTronTransaction(args);
+        expect(adapter.buildCustomApiTx).toHaveBeenCalledWith(expect.objectContaining({ feeLimit: 100_000_000 }));
+    });
+    it('builds a send of the sell asset when data is absent', async () => {
+        const { adapter, args } = makeArgs(USDT_TRON, {
+            type: 'tron',
+            to: TO,
+            value: '1',
+            memo: '=:ETH.ETH:0xabc',
+        });
+        expect(await getUnsignedTronTransaction(args)).toBe('send');
+        expect(adapter.buildSendApiTransaction).toHaveBeenCalledWith({
+            from: FROM,
+            to: TO,
+            accountNumber: 0,
+            value: '1',
+            chainSpecific: { contractAddress: USDT, memo: '=:ETH.ETH:0xabc', feeLimit: 27_000_000 },
+        });
+    });
+    it('throws without tron transactionData', () => {
+        const { args } = makeArgs(TRX, undefined);
+        expect(() => getUnsignedTronTransaction(args)).toThrow('Missing tron transactionData');
+    });
+});

package/dist/esm/utils/tron/index.d.ts

@@ -1,2 +1,4 @@
+export * from './constants.js';
+export * from './getTronNetworkFeeCryptoBaseUnit.js';
 export * from './getTronTransactionFees.js';
 export * from './getUnsignedTronTransaction.js';

package/dist/esm/utils/tron/index.js

@@ -1,2 +1,4 @@
+export * from './constants.js';
+export * from './getTronNetworkFeeCryptoBaseUnit.js';
 export * from './getTronTransactionFees.js';
 export * from './getUnsignedTronTransaction.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshiftoss/swapper",
-  "version": "20.2.0",
+  "version": "20.3.0",
   "repository": "https://github.com/shapeshift/web",
   "license": "MIT",
   "type": "module",
@@ -28,7 +28,7 @@
     "@coral-xyz/anchor": "0.29.0",
     "@cowprotocol/app-data": "^2.3.0",
     "@defuse-protocol/one-click-sdk-typescript": "^0.1.1-0.2",
-    "@gobob/bob-sdk": "5.11.1",
+    "@gobob/bob-sdk": "6.0.1",
     "@mysten/sui": "^1.45.2",
     "@shapeshiftoss/bitcoinjs-lib": "7.0.0-shapeshift.0",
     "@sniptt/monads": "^0.5.10",
@@ -50,13 +50,13 @@
     "retry-axios": "^2.6.0",
     "uuid": "^9.0.0",
     "viem": "2.55.11",
-    "@shapeshiftoss/caip": "^8.17.0",
-    "@shapeshiftoss/chain-adapters": "^11.5.1",
-    "@shapeshiftoss/contracts": "^1.0.7",
+    "@shapeshiftoss/caip": "^8.17.1",
+    "@shapeshiftoss/chain-adapters": "^11.6.0",
     "@shapeshiftoss/hdwallet-core": "^1.62.41",
-    "@shapeshiftoss/types": "^9.0.1",
-    "@shapeshiftoss/unchained-client": "^10.14.11",
-    "@shapeshiftoss/utils": "^1.3.0"
+    "@shapeshiftoss/contracts": "^1.1.0",
+    "@shapeshiftoss/types": "^9.1.0",
+    "@shapeshiftoss/utils": "^1.3.1",
+    "@shapeshiftoss/unchained-client": "^10.15.0"
   },
   "devDependencies": {
     "@types/lodash": "^4.14.178",

package/dist/cjs/swappers/SunioSwapper/utils/buildSwapRouteParameters.d.ts

@@ -1,14 +0,0 @@
-import type { SunioRoute } from '../types';
-export type SwapRouteParameters = {
-    path: string[];
-    poolVersion: string[];
-    versionLen: number[];
-    fees: number[];
-    swapData: {
-        amountIn: string;
-        amountOutMin: string;
-        recipient: string;
-        deadline: number;
-    };
-};
-export declare const buildSwapRouteParameters: (route: SunioRoute, sellAmountCryptoBaseUnit: string, minBuyAmountCryptoBaseUnit: string, recipient: string, slippageTolerancePercentageDecimal: string) => SwapRouteParameters;

package/dist/cjs/swappers/SunioSwapper/utils/buildSwapRouteParameters.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildSwapRouteParameters = void 0;
-const utils_1 = require("@shapeshiftoss/utils");
-const buildSwapRouteParameters = (route, sellAmountCryptoBaseUnit, minBuyAmountCryptoBaseUnit, recipient, slippageTolerancePercentageDecimal) => {
-    const path = route.tokens;
-    const poolVersion = route.poolVersions;
-    // 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. This relies on the Sun.io
-    // API returning poolVersions per-hop (poolVersions.length === tokens.length - 1),
-    // which it does — the router also accepts this un-collapsed form for same-version hops.
-    const versionLen = poolVersion.map((_, index) => (index === 0 ? 2 : 1));
-    const fees = route.poolFees.map(fee => Number(fee));
-    const amountOutWithSlippage = (0, utils_1.bn)(minBuyAmountCryptoBaseUnit)
-        .times((0, utils_1.bn)(1).minus(slippageTolerancePercentageDecimal))
-        .toFixed(0);
-    const swapData = {
-        amountIn: sellAmountCryptoBaseUnit,
-        amountOutMin: amountOutWithSlippage,
-        recipient,
-        deadline: Math.floor(Date.now() / 1000) + 60 * 20,
-    };
-    return {
-        path,
-        poolVersion,
-        versionLen,
-        fees,
-        swapData,
-    };
-};
-exports.buildSwapRouteParameters = buildSwapRouteParameters;

package/dist/cjs/swappers/SunioSwapper/utils/estimateSunioNetworkFee.d.ts

@@ -1,12 +0,0 @@
-import type { SunioRoute } from '../types';
-type EstimateSunioNetworkFeeArgs = {
-    rpcUrl: string;
-    apiKey: string;
-    route: SunioRoute;
-    sellAmountCryptoBaseUnit: string;
-    isSellingNativeTrx: boolean;
-    address: string | undefined;
-    slippageTolerancePercentageDecimal: string | undefined;
-};
-export declare const estimateSunioNetworkFeeCryptoBaseUnit: ({ rpcUrl, apiKey, route, sellAmountCryptoBaseUnit, isSellingNativeTrx, address, slippageTolerancePercentageDecimal, }: EstimateSunioNetworkFeeArgs) => Promise<string>;
-export {};