@shapeshiftoss/swapper 20.2.0 → 20.4.0

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/SymbiosisSwapper/SymbiosisSwapper.d.ts

@@ -0,0 +1,2 @@
+import type { Swapper } from '../../types.js';
+export declare const symbiosisSwapper: Swapper;

package/dist/esm/swappers/SymbiosisSwapper/SymbiosisSwapper.js

@@ -0,0 +1,5 @@
+import { executeEvmTransaction, executeTronTransaction } from '../../utils/index.js';
+export const symbiosisSwapper = {
+    executeEvmTransaction,
+    executeTronTransaction,
+};

package/dist/esm/swappers/SymbiosisSwapper/endpoints.d.ts

@@ -0,0 +1,2 @@
+import type { SwapperApi } from '../../types.js';
+export declare const symbiosisApi: SwapperApi;

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

@@ -0,0 +1,63 @@
+import { tronChainId } from '@shapeshiftoss/caip';
+import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import { checkEvmSwapStatus } from '../../utils/index.js';
+import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
+import { getTronTransactionFees, getUnsignedTronTransaction } from '../../utils/tron/index.js';
+import { getTradeQuote } from './getTradeQuote/getTradeQuote.js';
+import { getTradeRate } from './getTradeRate/getTradeRate.js';
+import { chainIdToSymbiosisChainId, SYMBIOSIS_EXPLORER_URL } from './utils/constants.js';
+import { getSymbiosisTradeStatus, isTronSourceTxFailed } from './utils/helpers.js';
+import { symbiosisService } from './utils/symbiosisService.js';
+export const symbiosisApi = {
+    getTradeQuote: (input, deps) => getTradeQuote(input, deps),
+    getTradeRate: (input, deps) => getTradeRate(input, deps),
+    getEvmTransactionFees,
+    getUnsignedEvmTransaction,
+    getTronTransactionFees,
+    getUnsignedTronTransaction,
+    checkTradeStatus: async ({ txHash, chainId, address, config, swap, fetchIsSmartContractAddressQuery, assertGetEvmChainAdapter, assertGetTronChainAdapter, }) => {
+        if (!swap)
+            throw new Error('Missing swap');
+        const evmSourceTxStatus = isEvmChainId(chainId)
+            ? await checkEvmSwapStatus({
+                txHash,
+                chainId,
+                address,
+                assertGetEvmChainAdapter,
+                fetchIsSmartContractAddressQuery,
+            })
+            : undefined;
+        if (evmSourceTxStatus && evmSourceTxStatus.status !== TxStatus.Confirmed) {
+            return evmSourceTxStatus;
+        }
+        const sourceTxHash = evmSourceTxStatus?.buyTxHash ?? txHash;
+        if (chainId === tronChainId) {
+            const sourceTx = await assertGetTronChainAdapter(chainId)
+                .httpProvider.getTransaction({ txid: sourceTxHash })
+                .catch(() => null);
+            if (!sourceTx?.confirmations) {
+                return { buyTxHash: undefined, status: TxStatus.Pending, message: undefined };
+            }
+            if (isTronSourceTxFailed(sourceTx)) {
+                return { buyTxHash: undefined, status: TxStatus.Failed, message: undefined };
+            }
+        }
+        const sellSymbiosisChainId = chainIdToSymbiosisChainId[chainId];
+        const buySymbiosisChainId = chainIdToSymbiosisChainId[swap.buyAsset.chainId];
+        const maybeStatusResponse = await symbiosisService.get(`${config.VITE_SYMBIOSIS_API_URL}/v2/tx/${sellSymbiosisChainId}/${sourceTxHash}`);
+        if (maybeStatusResponse.isErr()) {
+            return {
+                buyTxHash: undefined,
+                status: TxStatus.Unknown,
+                message: undefined,
+            };
+        }
+        const { data: response } = maybeStatusResponse.unwrap();
+        return {
+            ...getSymbiosisTradeStatus({ response, buySymbiosisChainId }),
+            swapperTxId: sourceTxHash,
+            swapperTxLink: `${SYMBIOSIS_EXPLORER_URL}/transactions/${sellSymbiosisChainId}/${sourceTxHash}`,
+        };
+    },
+};

package/dist/esm/swappers/SymbiosisSwapper/getTradeQuote/getTradeQuote.d.ts

@@ -0,0 +1,4 @@
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types.js';
+import type { SymbiosisTradeQuoteInput } from '../utils/types.js';
+export declare const getTradeQuote: (input: SymbiosisTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;

package/dist/esm/swappers/SymbiosisSwapper/getTradeQuote/getTradeQuote.js

@@ -0,0 +1,38 @@
+import { Err, Ok } from '@sniptt/monads';
+import { assertQuoteAddresses } from '../../../utils/index.js';
+import { getSymbiosisStepData } from '../utils/getSymbiosisStepData.js';
+import { getSymbiosisTradeContext } from '../utils/getSymbiosisTradeContext.js';
+export const getTradeQuote = async (input, deps) => {
+    const { accountNumber } = input;
+    const maybeAddresses = assertQuoteAddresses(input);
+    if (maybeAddresses.isErr())
+        return Err(maybeAddresses.unwrapErr());
+    const { sendAddress, receiveAddress } = maybeAddresses.unwrap();
+    const maybeContext = await getSymbiosisTradeContext({
+        input,
+        deps,
+        from: sendAddress,
+        to: receiveAddress,
+    });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getSymbiosisStepData({ ...stepDataArgs, type: 'quote', input });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { transactionData, networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeQuote = {
+        ...tradeCommon,
+        quoteOrRate: 'quote',
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                transactionData,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
+    };
+    return Ok([tradeQuote]);
+};

package/dist/esm/swappers/SymbiosisSwapper/getTradeRate/getTradeRate.d.ts

@@ -0,0 +1,4 @@
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight, SwapperDeps, TradeRate } from '../../../types.js';
+import type { SymbiosisTradeRateInput } from '../utils/types.js';
+export declare const getTradeRate: (input: SymbiosisTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;

package/dist/esm/swappers/SymbiosisSwapper/getTradeRate/getTradeRate.js

@@ -0,0 +1,30 @@
+import { Err, Ok } from '@sniptt/monads';
+import { getSymbiosisStepData } from '../utils/getSymbiosisStepData.js';
+import { getSymbiosisTradeContext } from '../utils/getSymbiosisTradeContext.js';
+import { getDefaultUserAddress } from '../utils/helpers.js';
+export const getTradeRate = async (input, deps) => {
+    const { accountNumber, sellAsset, buyAsset, sendAddress, receiveAddress } = input;
+    const from = sendAddress ?? getDefaultUserAddress(sellAsset.chainId);
+    const to = receiveAddress ?? getDefaultUserAddress(buyAsset.chainId);
+    const maybeContext = await getSymbiosisTradeContext({ input, deps, from, to });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getSymbiosisStepData({ ...stepDataArgs, type: 'rate', input });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeRate = {
+        ...tradeCommon,
+        quoteOrRate: 'rate',
+        receiveAddress: to,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
+    };
+    return Ok([tradeRate]);
+};

package/dist/esm/swappers/SymbiosisSwapper/index.d.ts

@@ -0,0 +1,2 @@
+export { symbiosisApi } from './endpoints.js';
+export { symbiosisSwapper } from './SymbiosisSwapper.js';

package/dist/esm/swappers/SymbiosisSwapper/index.js

@@ -0,0 +1,2 @@
+export { symbiosisApi } from './endpoints.js';
+export { symbiosisSwapper } from './SymbiosisSwapper.js';

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

@@ -0,0 +1,19 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+export declare const chainIdToSymbiosisChainId: Partial<Record<ChainId, number>>;
+export declare const symbiosisChainIdToChainId: Partial<Record<number, ChainId>>;
+export declare const SYMBIOSIS_DISABLED_PROVIDERS = "chainflip-bridge,thorchain-bridge,changelly,intent-solver";
+export declare const SYMBIOSIS_CROSSCHAIN_SWAP_KIND = "crosschain-swap";
+export declare const SYMBIOSIS_SRC_CHAIN_SWAP_LABEL = "src-chain-swap";
+export declare const SYMBIOSIS_PARTNER_SWAP_LABEL = "partner-swap";
+export declare const SYMBIOSIS_SEMI_CENTRALIZED_LABEL = "semi-centralized";
+export declare const SYMBIOSIS_MIN_SLIPPAGE_BPS = 10;
+export declare const SYMBIOSIS_MAX_SLIPPAGE_BPS = 1000;
+export declare const SYMBIOSIS_PARTNER_ADDRESS = "0xF5AA59151bE6515C4Ca68A0282CF68B3eA4846fC";
+export declare const SYMBIOSIS_PARTNER_FEE_BPS = "60";
+export declare const SYMBIOSIS_PARTNER_FEE_DESCRIPTION = "Partner fee";
+export declare const SYMBIOSIS_PARTNER_ID = "shapeshift";
+export declare const DEFAULT_SYMBIOSIS_EVM_USER_ADDRESS = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045";
+export declare const DEFAULT_SYMBIOSIS_TRON_USER_ADDRESS = "TLa2f6VPqDgRE67v1736s7bJ8Ray5wYjU7";
+export declare const SYMBIOSIS_TRON_BRIDGE_ENERGY = "470000";
+export declare const SYMBIOSIS_TRON_SOURCE_SWAP_ENERGY = "580000";
+export declare const SYMBIOSIS_EXPLORER_URL = "https://explorer.symbiosis.finance";

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

@@ -0,0 +1,61 @@
+import { abstractChainId, arbitrumChainId, avalancheChainId, baseChainId, berachainChainId, bscChainId, cronosChainId, ethChainId, fromChainId, gnosisChainId, hyperEvmChainId, katanaChainId, lineaChainId, mantleChainId, modeChainId, monadChainId, optimismChainId, plasmaChainId, polygonChainId, robinhoodChainId, scrollChainId, seiChainId, soneiumChainId, sonicChainId, tronChainId, unichainChainId, zkSyncEraChainId, } from '@shapeshiftoss/caip';
+const SYMBIOSIS_TRON_CHAIN_ID = 728126428;
+const SYMBIOSIS_SUPPORTED_EVM_CHAIN_IDS = [
+    ethChainId,
+    bscChainId,
+    polygonChainId,
+    avalancheChainId,
+    arbitrumChainId,
+    optimismChainId,
+    baseChainId,
+    gnosisChainId,
+    zkSyncEraChainId,
+    lineaChainId,
+    scrollChainId,
+    mantleChainId,
+    modeChainId,
+    seiChainId,
+    cronosChainId,
+    sonicChainId,
+    abstractChainId,
+    berachainChainId,
+    unichainChainId,
+    soneiumChainId,
+    hyperEvmChainId,
+    katanaChainId,
+    plasmaChainId,
+    monadChainId,
+    robinhoodChainId,
+];
+// Symbiosis uses the EVM chain reference as its chain id, and its own id for Tron
+const SYMBIOSIS_CHAIN_ID_ENTRIES = [
+    ...SYMBIOSIS_SUPPORTED_EVM_CHAIN_IDS.map((chainId) => [
+        chainId,
+        Number(fromChainId(chainId).chainReference),
+    ]),
+    [tronChainId, SYMBIOSIS_TRON_CHAIN_ID],
+];
+export const chainIdToSymbiosisChainId = Object.fromEntries(SYMBIOSIS_CHAIN_ID_ENTRIES);
+export const symbiosisChainIdToChainId = Object.fromEntries(SYMBIOSIS_CHAIN_ID_ENTRIES.map(([chainId, symbiosisChainId]) => [symbiosisChainId, chainId]));
+// Disabled liquidity providers: bridges we integrate directly, custodial Changelly, and intent routes that skip the partner fee
+export const SYMBIOSIS_DISABLED_PROVIDERS = 'chainflip-bridge,thorchain-bridge,changelly,intent-solver';
+export const SYMBIOSIS_CROSSCHAIN_SWAP_KIND = 'crosschain-swap';
+export const SYMBIOSIS_SRC_CHAIN_SWAP_LABEL = 'src-chain-swap';
+// Labels on routes with a leg outside Symbiosis
+export const SYMBIOSIS_PARTNER_SWAP_LABEL = 'partner-swap';
+export const SYMBIOSIS_SEMI_CENTRALIZED_LABEL = 'semi-centralized';
+// /v2/quote answers 'Slippage is too low' under 10 and 'too high' over 1000
+export const SYMBIOSIS_MIN_SLIPPAGE_BPS = 10;
+export const SYMBIOSIS_MAX_SLIPPAGE_BPS = 1000;
+// Our registered partner address and the fixed fee rate Symbiosis has configured for it
+export const SYMBIOSIS_PARTNER_ADDRESS = '0xF5AA59151bE6515C4Ca68A0282CF68B3eA4846fC';
+export const SYMBIOSIS_PARTNER_FEE_BPS = '60';
+export const SYMBIOSIS_PARTNER_FEE_DESCRIPTION = 'Partner fee';
+// Sent as X-Partner-Id so Symbiosis attributes our swaps to this client id in its explorer and metrics
+export const SYMBIOSIS_PARTNER_ID = 'shapeshift';
+export const DEFAULT_SYMBIOSIS_EVM_USER_ADDRESS = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045';
+export const DEFAULT_SYMBIOSIS_TRON_USER_ADDRESS = 'TLa2f6VPqDgRE67v1736s7bJ8Ray5wYjU7';
+// metaRoute energy over 31 mainnet calls on 2026-10-05: up to 467,826 bridging the sell token, up to 578,456 with a source swap first
+export const SYMBIOSIS_TRON_BRIDGE_ENERGY = '470000';
+export const SYMBIOSIS_TRON_SOURCE_SWAP_ENERGY = '580000';
+export const SYMBIOSIS_EXPLORER_URL = 'https://explorer.symbiosis.finance';

package/dist/esm/swappers/SymbiosisSwapper/utils/getSymbiosisStepData.d.ts

@@ -0,0 +1,26 @@
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.js';
+import type { SymbiosisSwapTx } from './types.js';
+type BaseArgs = {
+    swapTx: SymbiosisSwapTx;
+    sellAmountCryptoBaseUnit: string;
+    spenderAddress: string;
+    tronFallbackEnergy: string;
+};
+export type GetSymbiosisStepDataArgs = StepDataArgs<BaseArgs, {
+    from: string;
+}>;
+type SymbiosisRateStepData = {
+    networkFeeCryptoBaseUnit: string | undefined;
+};
+type SymbiosisQuoteStepData = {
+    transactionData: TxBuildData;
+    networkFeeCryptoBaseUnit: string;
+};
+export declare function getSymbiosisStepData(args: Extract<GetSymbiosisStepDataArgs, {
+    type: 'rate';
+}>): Promise<Result<SymbiosisRateStepData, SwapErrorRight>>;
+export declare function getSymbiosisStepData(args: Extract<GetSymbiosisStepDataArgs, {
+    type: 'quote';
+}>): Promise<Result<SymbiosisQuoteStepData, SwapErrorRight>>;
+export {};

package/dist/esm/swappers/SymbiosisSwapper/utils/getSymbiosisStepData.js

@@ -0,0 +1,102 @@
+import { fromChainId } from '@shapeshiftoss/caip';
+import { tron } from '@shapeshiftoss/chain-adapters';
+import { bnOrZero, 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 { getTronContractCallFallbackFeeCryptoBaseUnit, getTronContractCallNetworkFeeCryptoBaseUnit, } from '../../../utils/tron/index.js';
+import { chainIdToSymbiosisChainId } from './constants.js';
+import { buildSymbiosisTronCallData } from './helpers.js';
+export async function getSymbiosisStepData(args) {
+    const { swapTx, sellAsset, sellAmountCryptoBaseUnit, spenderAddress, tronFallbackEnergy, from, type, input, deps, } = args;
+    // Symbiosis adds its own fee to the native value on other route kinds - a step must send exactly the sell amount
+    const expectedValue = isToken(sellAsset.assetId) ? '0' : sellAmountCryptoBaseUnit;
+    if (!bnOrZero(swapTx.tx.value).eq(expectedValue)) {
+        return Err(makeTradeStepBuildFailedErr('getSymbiosisStepData'));
+    }
+    if (swapTx.tx.chainId !== chainIdToSymbiosisChainId[sellAsset.chainId]) {
+        return Err(makeTradeStepBuildFailedErr('getSymbiosisStepData'));
+    }
+    switch (swapTx.type) {
+        case 'evm': {
+            const { tx } = swapTx;
+            const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+            const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
+            const transactionData = {
+                type: 'evm',
+                chainId: Number(fromChainId(sellAsset.chainId).chainReference),
+                to: tx.to,
+                data: tx.data,
+                value: tx.value ?? '0',
+            };
+            const stateOverride = { sellAsset, sellAmountCryptoBaseUnit, spenderAddress };
+            if (type === 'rate') {
+                const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+                    adapter,
+                    transactionData,
+                    from,
+                    supportsEIP1559,
+                    stateOverride,
+                }).catch(() => undefined);
+                const stepData = { networkFeeCryptoBaseUnit };
+                return Ok(stepData);
+            }
+            try {
+                const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+                    adapter,
+                    transactionData,
+                    from,
+                    supportsEIP1559,
+                    stateOverride,
+                });
+                const stepData = { transactionData, networkFeeCryptoBaseUnit };
+                return Ok(stepData);
+            }
+            catch (error) {
+                return Err(makeNetworkFeeEstimationFailedErr('getSymbiosisStepData', error));
+            }
+        }
+        case 'tron': {
+            const { tx } = swapTx;
+            if (!tx.functionSelector)
+                return Err(makeTradeStepBuildFailedErr('getSymbiosisStepData'));
+            const adapter = deps.assertGetTronChainAdapter(sellAsset.chainId);
+            const call = {
+                to: tx.to,
+                data: buildSymbiosisTronCallData({ functionSelector: tx.functionSelector, data: tx.data }),
+                value: tx.value ?? '0',
+            };
+            if (type === 'rate') {
+                const networkFeeCryptoBaseUnit = await getTronContractCallFallbackFeeCryptoBaseUnit({
+                    adapter,
+                    energy: tronFallbackEnergy,
+                    bandwidthBytes: tron.getTronContractCallBandwidthBytes(call.data),
+                    contractAddress: call.to,
+                    fullEnergyOnShareLookupFailure: true,
+                }).catch(() => undefined);
+                const stepData = { networkFeeCryptoBaseUnit };
+                return Ok(stepData);
+            }
+            try {
+                const stepData = {
+                    transactionData: { type: 'tron', ...call },
+                    networkFeeCryptoBaseUnit: await getTronContractCallNetworkFeeCryptoBaseUnit({
+                        adapter,
+                        transactionData: call,
+                        from,
+                        sellAsset,
+                        sellAmountCryptoBaseUnit,
+                        spenderAddress,
+                        fallbackEnergy: tronFallbackEnergy,
+                    }),
+                };
+                return Ok(stepData);
+            }
+            catch (error) {
+                return Err(makeNetworkFeeEstimationFailedErr('getSymbiosisStepData', error));
+            }
+        }
+        default:
+            return Err(makeTradeStepBuildFailedErr('getSymbiosisStepData'));
+    }
+}

package/dist/esm/swappers/SymbiosisSwapper/utils/getSymbiosisStepData.test.d.ts

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