@shapeshiftoss/swapper 20.1.1 → 20.3.0

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 {};

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

@@ -0,0 +1,175 @@
+import { tronChainId } from '@shapeshiftoss/caip';
+import { tron } from '@shapeshiftoss/chain-adapters';
+import { describe, expect, it, vi } from 'vitest';
+import { ETH } from '../../../utils/test-data/assets.js';
+import { buildSunioSwapCalldata } from './buildSwapContractCall.js';
+import { SUNIO_FALLBACK_SWAP_ENERGY_NATIVE, SUNIO_FALLBACK_SWAP_ENERGY_TRC20, SUNIO_SMART_ROUTER_CONTRACT, } from './constants.js';
+import { getSunioStepData } from './getSunioStepData.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 route = {
+    tokens: ['T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb', USDT],
+    poolVersions: ['v2'],
+    poolFees: ['0'],
+};
+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 = {
+    route,
+    sellAmountCryptoBaseUnit: '100000000',
+    buyAmountCryptoBaseUnit: '30000000',
+};
+// The calldata is fixed-width ABI, so its size doesn't depend on the recipient or deadline
+const calldataBandwidthBytes = tron.getTronContractCallBandwidthBytes(buildSunioSwapCalldata({
+    route,
+    sellAmountCryptoBaseUnit: '100000000',
+    minBuyAmountCryptoBaseUnit: '30000000',
+    recipient: FROM,
+    slippageTolerancePercentageDecimal: '0.005',
+    deadline: 0,
+}));
+const fallbackFee = (energy) => String(Number(energy) * 1.2 * 100 + calldataBandwidthBytes * 1000);
+describe('getSunioStepData', () => {
+    describe('quote', () => {
+        it('carries the router call as transactionData and simulates it', async () => {
+            const adapter = tronAdapter();
+            const actual = await getSunioStepData({
+                ...baseArgs,
+                type: 'quote',
+                input: {
+                    receiveAddress: FROM,
+                    slippageTolerancePercentageDecimal: '0.01',
+                },
+                deps: makeDeps(adapter),
+                sellAsset: TRX,
+                from: FROM,
+            });
+            const { transactionData, networkFeeCryptoBaseUnit, deadline } = actual.unwrap();
+            expect(transactionData).toMatchObject({
+                type: 'tron',
+                to: SUNIO_SMART_ROUTER_CONTRACT,
+                value: '100000000',
+            });
+            // swapExactInput selector
+            expect(transactionData.data).toMatch(/^0x[0-9a-f]{8}/);
+            expect(networkFeeCryptoBaseUnit).toBe('9000000');
+            expect(deadline).toBeGreaterThan(Date.now());
+            expect(adapter.getFeeData).toHaveBeenCalledWith({
+                to: SUNIO_SMART_ROUTER_CONTRACT,
+                value: '100000000',
+                chainSpecific: { from: FROM, data: transactionData.data, requireEnergyShare: true },
+            });
+        });
+        it('sends no value for a token sell', async () => {
+            const actual = await getSunioStepData({
+                ...baseArgs,
+                type: 'quote',
+                input: { receiveAddress: FROM },
+                deps: makeDeps(tronAdapter()),
+                sellAsset: USDT_TRON,
+                from: FROM,
+            });
+            expect(actual.unwrap().transactionData.value).toBe('0');
+        });
+        it('fails a native quote when the simulation fails', async () => {
+            const adapter = tronAdapter();
+            adapter.getFeeData.mockRejectedValue(new Error('REVERT opcode executed'));
+            const actual = await getSunioStepData({
+                ...baseArgs,
+                type: 'quote',
+                input: { receiveAddress: FROM },
+                deps: makeDeps(adapter),
+                sellAsset: TRX,
+                from: FROM,
+            });
+            expect(actual.isErr()).toBe(true);
+        });
+        it('prices the token worst case when the allowance is not granted yet', async () => {
+            const adapter = tronAdapter({ allowance: '0' });
+            adapter.getFeeData.mockRejectedValue(new Error('REVERT opcode executed'));
+            const actual = await getSunioStepData({
+                ...baseArgs,
+                type: 'quote',
+                input: { receiveAddress: FROM },
+                deps: makeDeps(adapter),
+                sellAsset: USDT_TRON,
+                from: FROM,
+            });
+            const { transactionData, networkFeeCryptoBaseUnit } = actual.unwrap();
+            expect(transactionData.to).toBe(SUNIO_SMART_ROUTER_CONTRACT);
+            expect(networkFeeCryptoBaseUnit).toBe(fallbackFee(SUNIO_FALLBACK_SWAP_ENERGY_TRC20));
+            expect(adapter.httpProvider.getTrc20Allowance).toHaveBeenCalledWith({
+                contractAddress: USDT,
+                owner: FROM,
+                spender: SUNIO_SMART_ROUTER_CONTRACT,
+            });
+        });
+        it('fails a token quote that reverts with its allowance in place', async () => {
+            const adapter = tronAdapter({ allowance: '100000000' });
+            adapter.getFeeData.mockRejectedValue(new Error('REVERT opcode executed'));
+            const actual = await getSunioStepData({
+                ...baseArgs,
+                type: 'quote',
+                input: { receiveAddress: FROM },
+                deps: makeDeps(adapter),
+                sellAsset: USDT_TRON,
+                from: FROM,
+            });
+            expect(actual.isErr()).toBe(true);
+        });
+    });
+    describe('rate', () => {
+        it('simulates from the receive address when present', async () => {
+            const actual = await getSunioStepData({
+                ...baseArgs,
+                type: 'rate',
+                input: { receiveAddress: FROM },
+                deps: makeDeps(tronAdapter()),
+                sellAsset: TRX,
+                from: FROM,
+            });
+            expect(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '9000000' });
+        });
+        it('prices the measured worst case without an address to simulate from', async () => {
+            const actual = await getSunioStepData({
+                ...baseArgs,
+                type: 'rate',
+                input: {},
+                deps: makeDeps(tronAdapter()),
+                sellAsset: TRX,
+            });
+            expect(actual.unwrap()).toEqual({
+                networkFeeCryptoBaseUnit: fallbackFee(SUNIO_FALLBACK_SWAP_ENERGY_NATIVE),
+            });
+        });
+        it('prices the token worst case when a pre-approval simulation reverts', async () => {
+            const adapter = tronAdapter();
+            adapter.getFeeData.mockRejectedValue(new Error('REVERT opcode executed'));
+            const actual = await getSunioStepData({
+                ...baseArgs,
+                type: 'rate',
+                input: { receiveAddress: FROM },
+                deps: makeDeps(adapter),
+                sellAsset: USDT_TRON,
+                from: FROM,
+            });
+            expect(actual.unwrap()).toEqual({
+                networkFeeCryptoBaseUnit: fallbackFee(SUNIO_FALLBACK_SWAP_ENERGY_TRC20),
+            });
+        });
+    });
+});

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

@@ -4,7 +4,7 @@ import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { getInputOutputRate, makeSwapErrorRight } from '../../../utils/index.js';
 import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
 import { DEFAULT_SLIPPAGE_PERCENTAGE, SUNIO_SMART_ROUTER_CONTRACT } from './constants.js';
-import { fetchSunioQuote } from './fetchFromSunio.js';
+import { fetchSunioQuote } from './fetchSunioQuote.js';
 import { assertValidTrade } from './helpers.js';
 import { sunioServiceFactory } from './sunioService.js';
 export const getSunioTradeContext = async ({ input, deps, }) => {
@@ -84,6 +84,7 @@ export const getSunioTradeContext = async ({ input, deps, }) => {
                 deps,
                 sellAsset,
                 sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                buyAmountCryptoBaseUnit,
                 route: bestRoute,
             },
         });

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

@@ -1,9 +1,10 @@
 import { fromAssetId, tronChainId } from '@shapeshiftoss/caip';
+import { tron } from '@shapeshiftoss/chain-adapters';
 import { isToken } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { makeSwapErrorRight } from '../../../utils/index.js';
-import { SUNIO_SUPPORTED_CHAIN_IDS, SUNIO_TRON_NATIVE_ADDRESS } from './constants.js';
+import { SUNIO_SUPPORTED_CHAIN_IDS } from './constants.js';
 export const isSupportedChainId = (chainId) => {
     return SUNIO_SUPPORTED_CHAIN_IDS.includes(chainId);
 };
@@ -12,7 +13,7 @@ export const assetIdToTronToken = (assetId) => {
         const { assetReference } = fromAssetId(assetId);
         return assetReference;
     }
-    return SUNIO_TRON_NATIVE_ADDRESS;
+    return tron.TRON_ZERO_ADDRESS;
 };
 export const assertValidTrade = ({ sellAsset, buyAsset, }) => {
     if (!isSupportedChainId(sellAsset.chainId)) {

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

@@ -1,12 +1,11 @@
-import { SwapperName } from '../../types.js';
 import { getCosmosSdkTransactionFees, getUnsignedCosmosSdkTransaction } from '../../utils/cosmossdk/index.js';
 import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
 import { getSolanaTransactionFees, getUnsignedSolanaTransaction } from '../../utils/solana/index.js';
-import { checkTradeStatus, tron } from '../../utils/thorchain/index.js';
+import { checkTradeStatus } from '../../utils/thorchain/index.js';
+import { getTronTransactionFees, getUnsignedTronTransaction } from '../../utils/tron/index.js';
 import { getUnsignedUtxoTransaction, getUtxoTransactionFees } from '../../utils/utxo/index.js';
 import { getTradeQuote } from './getTradeQuote/getTradeQuote.js';
 import { getTradeRate } from './getTradeRate/getTradeRate.js';
-const swapperName = SwapperName.Thorchain;
 export const thorchainApi = {
     getTradeRate: (input, deps) => getTradeRate(input, deps),
     getTradeQuote: (input, deps) => getTradeQuote(input, deps),
@@ -18,8 +17,8 @@ export const thorchainApi = {
     getCosmosSdkTransactionFees,
     getUnsignedSolanaTransaction,
     getSolanaTransactionFees,
-    getUnsignedTronTransaction: input => tron.getUnsignedTronTransaction(input, swapperName),
-    getTronTransactionFees: input => tron.getTronTransactionFees(input, swapperName),
+    getUnsignedTronTransaction,
+    getTronTransactionFees,
     checkTradeStatus: input => {
         const { config } = input;
         const nodeUrl = `${config.VITE_THORCHAIN_NODE_URL}/thorchain`;

package/dist/esm/swappers/ThorchainSwapper/utils/addL1ToLongtailPartsToMemo/addL1ToLongtailPartsToMemo.js

@@ -34,7 +34,12 @@ export const addL1ToLongtailPartsToMemo = ({ sellAssetChainId, quotedMemo, aggre
         finalAssetAddress: finalAssetContractAddressShortened,
     });
     const [prefix, nativeAssetName, address, nativeAssetLimitWithManualSlippage, affiliate, affiliateBps, aggregatorLastTwoChars, finalAssetContract,] = quotedMemoWithAggregatorAndFinalAssetContract.split(MEMO_PART_DELIMITER);
-    const shortenedNativeAssetName = shortenedNativeAssetNameByNativeAssetName[nativeAssetName];
+    // THORNode quote memos may already use the shortened native asset name
+    const shortenedNativeAssetNames = Object.values(shortenedNativeAssetNameByNativeAssetName);
+    const isAlreadyShortened = shortenedNativeAssetNames.includes(nativeAssetName);
+    const shortenedNativeAssetName = isAlreadyShortened
+        ? nativeAssetName
+        : shortenedNativeAssetNameByNativeAssetName[nativeAssetName];
     assert(shortenedNativeAssetName, 'cannot find shortened native asset name');
     const memoWithoutFinalAssetLimit = [
         prefix,

package/dist/esm/swappers/ThorchainSwapper/utils/addL1ToLongtailPartsToMemo/addL1ToLongtailPartsToMemo.test.js

@@ -35,6 +35,21 @@ describe('addL1ToLongtailPartsToMemo', () => {
         // The aggregator will turn the finalAssetAmountOut from 94136714201 to 9413671420 using the last 2 bytes as exponents
         `=:e:0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6:42:ss:100:d2:a6df4741:94136714201`);
     });
+    it('should accept a quoted memo with an already shortened native asset name', () => {
+        const finalAssetAmountOut = '9508759019';
+        const quotedMemo = `=:e:0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6:42:ss:100`;
+        const modifiedMemo = addL1ToLongtailPartsToMemo({
+            sellAssetChainId: ethChainId,
+            quotedMemo,
+            aggregator: AGGREGATOR_ADDRESS,
+            finalAssetAssetId: FINAL_ASSET_ASSETID,
+            finalAssetAmountOut,
+            slippageBps,
+            longtailTokens: THORCHAIN_ASSETIDS_ONE_COLLISION,
+            affiliate: THORCHAIN_AFFILIATE_NAME,
+        });
+        expect(modifiedMemo).toBe(`=:e:0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6:42:ss:100:d2:a6df4741:94136714201`);
+    });
     it('should throw if chainId is BCH and initial memo length is > 220', () => {
         const finalAssetAmountOut = '2083854765519275828179229';
         const memoOver220Bytes = `=:ETH.ETH:${REALLY_BIG_ADDRESS}:42:ss:100`;

package/dist/esm/swappers/ThorchainSwapper/utils/assertValidLongtailTrade.js

@@ -67,5 +67,12 @@ export const assertValidL1ToLongtailTrade = async ({ sellAsset, buyAsset, deps,
             details: { sellAssetChainId: sellAsset.chainId },
         }));
     }
+    if (sellAsset.assetId === buyAssetFeeAsset.assetId) {
+        return Err(makeSwapErrorRight({
+            message: `[getThorTradeQuote] - Cannot swap ${sellAsset.assetId} to itself before the aggregator.`,
+            code: TradeQuoteError.UnsupportedTradePair,
+            details: { buyAsset, sellAsset },
+        }));
+    }
     return Ok({ buyAssetFeeAsset, longtailTokens });
 };

package/dist/esm/swappers/ThorchainSwapper/utils/getL1ToLongtailQuote.js

@@ -1,4 +1,3 @@
-import { TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET } from '@shapeshiftoss/contracts';
 import { convertDecimalPercentageToBasisPoints } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
@@ -82,7 +81,6 @@ export const getL1ToLongtailQuote = async (input, deps, streamingInterval, swapp
                 buyAmountAfterFeesCryptoBaseUnit: quotedAmountOut.toString(),
                 // This is wrong, we should get the get the value before fees or display ETH value received after the thorchain bridge
                 buyAmountBeforeFeesCryptoBaseUnit: quotedAmountOut.toString(),
-                allowanceContract: TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET,
                 transactionData,
                 feeData: { ...s.feeData, networkFeeCryptoBaseUnit },
             })),

package/dist/esm/swappers/ThorchainSwapper/utils/getL1ToLongtailRate.js

@@ -1,4 +1,3 @@
-import { TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET } from '@shapeshiftoss/contracts';
 import { Err, Ok } from '@sniptt/monads';
 import { getSuccessfulTrades, getThorL1TradeRate, TradeType } from '../../../utils/thorchain/index.js';
 import { assertValidL1ToLongtailTrade } from './assertValidLongtailTrade.js';
@@ -35,7 +34,6 @@ export const getL1ToLongtailRate = async (input, deps, streamingInterval, swappe
                 buyAmountAfterFeesCryptoBaseUnit: quotedAmountOut.toString(),
                 // This is wrong, we should get the get the value before fees or display ETH value received after the thorchain bridge
                 buyAmountBeforeFeesCryptoBaseUnit: quotedAmountOut.toString(),
-                allowanceContract: TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET,
             })),
             isLongtail: true,
         });

package/dist/esm/swappers/ThorchainSwapper/utils/getUniqueAddressSubstring/getUniqueAddressSubstring.d.ts

@@ -1,2 +1,2 @@
 import type { AssetId } from '@shapeshiftoss/caip';
-export declare const getUniqueAddressSubstring: (destinationAssetId: AssetId, longTailAssetIds: AssetId[]) => AssetId;
+export declare const getUniqueAddressSubstring: (destinationAssetId: AssetId, longTailAssetIds: AssetId[]) => string;

package/dist/esm/swappers/ThorchainSwapper/utils/getUniqueAddressSubstring/getUniqueAddressSubstring.js

@@ -1,23 +1,20 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+const MINIMUM_UNIQUE_SUBSTRING = 2;
+// Mirrors THORNode's externalAssetMatch: a case-insensitive suffix match against the target chain's token list only
 export const getUniqueAddressSubstring = (destinationAssetId, longTailAssetIds) => {
-    const MINIMUM_UNIQUE_SUBSTRING = 2;
-    let maybeShortenedDestinationAddress = destinationAssetId;
-    const substringsCount = {};
-    for (let length = MINIMUM_UNIQUE_SUBSTRING; length <= destinationAssetId.length - 2; length++) {
-        const currentSubstring = destinationAssetId.slice(-length);
-        substringsCount[currentSubstring] = 0;
+    const { chainId, assetReference } = fromAssetId(destinationAssetId);
+    const address = assetReference.toLowerCase();
+    const sameChainAddresses = longTailAssetIds
+        .map(assetId => fromAssetId(assetId))
+        .filter(asset => asset.chainId === chainId)
+        .map(asset => asset.assetReference.toLowerCase());
+    if (!sameChainAddresses.includes(address))
+        return address;
+    for (let length = MINIMUM_UNIQUE_SUBSTRING; length < address.length; length++) {
+        const suffix = address.slice(-length);
+        const matchCount = sameChainAddresses.filter(sameChainAddress => sameChainAddress.endsWith(suffix)).length;
+        if (matchCount === 1)
+            return suffix;
     }
-    longTailAssetIds.forEach(assetId => {
-        Object.keys(substringsCount).forEach(substring => {
-            if (assetId.includes(substring)) {
-                substringsCount[substring] += 1;
-            }
-        });
-    });
-    for (const [substring, count] of Object.entries(substringsCount)) {
-        if (count === 1) {
-            maybeShortenedDestinationAddress = substring;
-            break;
-        }
-    }
-    return maybeShortenedDestinationAddress;
+    return address;
 };

package/dist/esm/swappers/ThorchainSwapper/utils/getUniqueAddressSubstring/getUniqueAddressSubstring.test.js

@@ -1,5 +1,6 @@
-import { ethChainId, toAssetId } from '@shapeshiftoss/caip';
+import { bscChainId, ethChainId, toAssetId } from '@shapeshiftoss/caip';
 import { describe, expect, it } from 'vitest';
+import longtailTokens from '../../generated/generatedThorLongtailTokens.json';
 import { getUniqueAddressSubstring } from './getUniqueAddressSubstring.js';
 const FINAL_ASSET_ASSETID = toAssetId({
     chainId: ethChainId,
@@ -16,6 +17,16 @@ const BIGGER_COLLIDING_FINAL_ASSETID = toAssetId({
     assetReference: '0xa0b86991c6218b36c1d19d4a2e9eb032a6dF4741',
     assetNamespace: 'erc20',
 });
+const SAME_ADDRESS_OTHER_CHAIN_ASSETID = toAssetId({
+    chainId: bscChainId,
+    assetReference: '0x8a65ac0E23F31979db06Ec62Af62b432a6dF4741',
+    assetNamespace: 'erc20',
+});
+const ONE_INCH_ASSETID = toAssetId({
+    chainId: ethChainId,
+    assetReference: '0x111111111117dc0aa78b770fa6a738034120c302',
+    assetNamespace: 'erc20',
+});
 const SHORTENED_FINAL_ASSET_ADDRESS = 'a6df4741';
 const BIGGER_SHORTENED_FINAL_ASSET_ADDRESS = '432a6df4741';
 const THORCHAIN_ASSETIDS_ONE_COLLISION = [FINAL_ASSET_ASSETID, COLLIDING_FINAL_ASSETID];
@@ -33,4 +44,21 @@ describe('getUniqueAddressSubstring', () => {
         const substring = getUniqueAddressSubstring(FINAL_ASSET_ASSETID, THORCHAIN_ASSETIDS_TWO_COLLISION);
         expect(substring).toBe(BIGGER_SHORTENED_FINAL_ASSET_ADDRESS);
     });
+    it('should ignore the same address on other chains', () => {
+        const substring = getUniqueAddressSubstring(FINAL_ASSET_ASSETID, [
+            ...THORCHAIN_ASSETIDS_ONE_COLLISION,
+            SAME_ADDRESS_OTHER_CHAIN_ASSETID,
+        ]);
+        expect(substring).toBe(SHORTENED_FINAL_ASSET_ADDRESS);
+    });
+    it('should return the full address when the asset is not in the list', () => {
+        const substring = getUniqueAddressSubstring(FINAL_ASSET_ASSETID, [COLLIDING_FINAL_ASSETID]);
+        expect(substring).toBe('0x8a65ac0e23f31979db06ec62af62b432a6df4741');
+    });
+    it('should return a hex suffix for an address listed on multiple chains', () => {
+        expect(longtailTokens).toContain(ONE_INCH_ASSETID);
+        const substring = getUniqueAddressSubstring(ONE_INCH_ASSETID, longtailTokens);
+        expect(substring).toMatch(/^[0-9a-f]+$/);
+        expect('0x111111111117dc0aa78b770fa6a738034120c302'.endsWith(substring)).toBe(true);
+    });
 });