@shapeshiftoss/swapper 20.3.0 → 20.5.0

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

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

@@ -0,0 +1,159 @@
+import { tronAssetId, tronChainId } from '@shapeshiftoss/caip';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { TradeQuoteError } from '../../../types.js';
+import { getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
+import { ETH, ETH_ARBITRUM, USDC_ARBITRUM } from '../../../utils/test-data/assets.js';
+import { getTronContractCallNetworkFeeCryptoBaseUnit } from '../../../utils/tron/index.js';
+import { getSymbiosisStepData } from './getSymbiosisStepData.js';
+vi.mock('../../../utils/evm', () => ({
+    getEvmNetworkFeeCryptoBaseUnit: vi.fn(),
+}));
+vi.mock('../../../utils/tron', () => ({
+    getTronContractCallFallbackFeeCryptoBaseUnit: vi.fn(),
+    getTronContractCallNetworkFeeCryptoBaseUnit: vi.fn(),
+}));
+const TRX = {
+    ...ETH,
+    assetId: tronAssetId,
+    chainId: tronChainId,
+    symbol: 'TRX',
+    precision: 6,
+};
+const ROUTER = '0x3743c756b64ECd0770f1d4f47696A73d2A46dcbe';
+const TRON_ROUTER = 'TPuaJ6gnYfE9gLUDFrbWbPx3tMnjG8max1';
+const FROM = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045';
+const TRON_FROM = 'TLa2f6VPqDgRE67v1736s7bJ8Ray5wYjU7';
+const deps = {
+    assertGetEvmChainAdapter: vi.fn(() => ({})),
+    assertGetTronChainAdapter: vi.fn(() => ({})),
+};
+const quoteInput = { supportsEIP1559: true };
+const evmSwapTx = {
+    type: 'evm',
+    tx: { chainId: 42161, to: ROUTER, data: '0xa11b1198', value: '0' },
+};
+const tronSwapTx = {
+    type: 'tron',
+    tx: {
+        chainId: 728126428,
+        from: TRON_FROM,
+        to: TRON_ROUTER,
+        data: '0x0020',
+        value: '500000000',
+        feeLimit: 200000000,
+        functionSelector: 'metaRoute((bytes,bytes,address[],address,address,uint256,bool,address,bytes))',
+    },
+};
+const evmArgs = {
+    swapTx: evmSwapTx,
+    sellAsset: USDC_ARBITRUM,
+    sellAmountCryptoBaseUnit: '100000000',
+    spenderAddress: ROUTER,
+    tronFallbackEnergy: '470000',
+    from: FROM,
+    deps,
+};
+const tronArgs = {
+    swapTx: tronSwapTx,
+    sellAsset: TRX,
+    sellAmountCryptoBaseUnit: '500000000',
+    spenderAddress: '',
+    tronFallbackEnergy: '580000',
+    from: TRON_FROM,
+    deps,
+};
+describe('getSymbiosisStepData', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('evm', () => {
+        it('fails to build when a token sell carries native value', async () => {
+            const swapTx = {
+                type: 'evm',
+                tx: { ...evmSwapTx.tx, value: '300000000000000' },
+            };
+            const result = await getSymbiosisStepData({
+                ...evmArgs,
+                swapTx,
+                type: 'quote',
+                input: quoteInput,
+            });
+            expect(result.unwrapErr().code).toBe(TradeQuoteError.InvalidResponse);
+            expect(getEvmNetworkFeeCryptoBaseUnit).not.toHaveBeenCalled();
+        });
+        it('fails to build when a native sell sends more than the sell amount', async () => {
+            const swapTx = {
+                type: 'evm',
+                tx: { ...evmSwapTx.tx, value: '50300000000000000' },
+            };
+            const result = await getSymbiosisStepData({
+                ...evmArgs,
+                swapTx,
+                sellAsset: ETH_ARBITRUM,
+                sellAmountCryptoBaseUnit: '50000000000000000',
+                type: 'quote',
+                input: quoteInput,
+            });
+            expect(result.unwrapErr().code).toBe(TradeQuoteError.InvalidResponse);
+            expect(getEvmNetworkFeeCryptoBaseUnit).not.toHaveBeenCalled();
+        });
+        it('fails to build when the payload is for another chain', async () => {
+            const swapTx = { type: 'evm', tx: { ...evmSwapTx.tx, chainId: 1 } };
+            const result = await getSymbiosisStepData({
+                ...evmArgs,
+                swapTx,
+                type: 'quote',
+                input: quoteInput,
+            });
+            expect(result.unwrapErr().code).toBe(TradeQuoteError.InvalidResponse);
+            expect(getEvmNetworkFeeCryptoBaseUnit).not.toHaveBeenCalled();
+        });
+        it('builds a native sell whose value is exactly the sell amount', async () => {
+            vi.mocked(getEvmNetworkFeeCryptoBaseUnit).mockResolvedValue('1234');
+            const swapTx = {
+                type: 'evm',
+                tx: { ...evmSwapTx.tx, value: '50000000000000000' },
+            };
+            const result = await getSymbiosisStepData({
+                ...evmArgs,
+                swapTx,
+                sellAsset: ETH_ARBITRUM,
+                sellAmountCryptoBaseUnit: '50000000000000000',
+                type: 'quote',
+                input: quoteInput,
+            });
+            expect(result.isOk()).toBe(true);
+        });
+    });
+    describe('tron', () => {
+        const expectedCall = { to: TRON_ROUTER, data: '0xa11b11980020', value: '500000000' };
+        it('assembles the contract call and prices it for a quote', async () => {
+            vi.mocked(getTronContractCallNetworkFeeCryptoBaseUnit).mockResolvedValue('45000000');
+            const result = await getSymbiosisStepData({ ...tronArgs, type: 'quote', input: quoteInput });
+            expect(result.unwrap()).toEqual({
+                transactionData: { type: 'tron', ...expectedCall },
+                networkFeeCryptoBaseUnit: '45000000',
+            });
+            expect(getTronContractCallNetworkFeeCryptoBaseUnit).toHaveBeenCalledWith(expect.objectContaining({
+                transactionData: expectedCall,
+                from: TRON_FROM,
+                spenderAddress: '',
+                fallbackEnergy: '580000',
+            }));
+        });
+        it('fails to build when the response has no function selector', async () => {
+            const swapTx = {
+                type: 'tron',
+                tx: { ...tronSwapTx.tx, functionSelector: undefined },
+            };
+            const result = await getSymbiosisStepData({
+                ...tronArgs,
+                swapTx,
+                type: 'quote',
+                input: quoteInput,
+            });
+            expect(result.unwrapErr().code).toBe(TradeQuoteError.InvalidResponse);
+            expect(getTronContractCallNetworkFeeCryptoBaseUnit).not.toHaveBeenCalled();
+        });
+    });
+});

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

@@ -0,0 +1,17 @@
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types.js';
+import type { GetSymbiosisStepDataArgs } from './getSymbiosisStepData.js';
+import type { SymbiosisTradeQuoteInput, SymbiosisTradeRateInput } from './types.js';
+type SymbiosisTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    stepDataArgs: Omit<GetSymbiosisStepDataArgs, 'type' | 'input'>;
+};
+export declare const getSymbiosisTradeContext: ({ input, deps, from, to, }: {
+    input: SymbiosisTradeQuoteInput | SymbiosisTradeRateInput;
+    deps: SwapperDeps;
+    from: string;
+    to: string;
+}) => Promise<Result<SymbiosisTradeContext, SwapErrorRight>>;
+export {};

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

@@ -0,0 +1,139 @@
+import { bn, isToken } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import axios from 'axios';
+import { v4 as uuid } from 'uuid';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils/index.js';
+import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
+import { SYMBIOSIS_DISABLED_PROVIDERS, SYMBIOSIS_PARTNER_FEE_BPS, SYMBIOSIS_PARTNER_FEE_DESCRIPTION, } from './constants.js';
+import { assertValidTrade, getSymbiosisPartnerAddress, getSymbiosisProtocolFees, getSymbiosisSlippageBps, getSymbiosisTokenAddress, getSymbiosisTronFallbackEnergy, isSymbiosisRouteSupported, symbiosisErrorToTradeQuoteError, } from './helpers.js';
+import { symbiosisService } from './symbiosisService.js';
+export const getSymbiosisTradeContext = async ({ input, deps, from, to, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const assertion = assertValidTrade({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const { sellSymbiosisChainId, buySymbiosisChainId } = assertion.unwrap();
+    const slippageBps = getSymbiosisSlippageBps(input.slippageTolerancePercentageDecimal ??
+        getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Symbiosis));
+    const maybePartnerAddress = getSymbiosisPartnerAddress(affiliateBps);
+    if (maybePartnerAddress.isErr())
+        return Err(maybePartnerAddress.unwrapErr());
+    const partnerAddress = maybePartnerAddress.unwrap();
+    const request = {
+        tokenAmountIn: {
+            chainId: sellSymbiosisChainId,
+            address: getSymbiosisTokenAddress(sellAsset),
+            decimals: sellAsset.precision,
+            amount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        },
+        tokenOut: {
+            chainId: buySymbiosisChainId,
+            address: getSymbiosisTokenAddress(buyAsset),
+            decimals: buyAsset.precision,
+        },
+        from,
+        to,
+        slippage: slippageBps,
+        disabledProviders: SYMBIOSIS_DISABLED_PROVIDERS,
+        partnerAddress,
+    };
+    const maybeQuote = await symbiosisService.post(`${deps.config.VITE_SYMBIOSIS_API_URL}/v2/quote`, request);
+    if (maybeQuote.isErr()) {
+        const { cause } = maybeQuote.unwrapErr();
+        if (!axios.isAxiosError(cause)) {
+            return Err(makeSwapErrorRight({
+                message: 'Unknown error',
+                code: TradeQuoteError.UnknownError,
+                cause,
+            }));
+        }
+        if (cause.response?.status === 429) {
+            return Err(makeSwapErrorRight({
+                message: 'Symbiosis rate limit exceeded',
+                code: TradeQuoteError.RateLimitExceeded,
+            }));
+        }
+        const message = cause.response?.data?.message;
+        return Err(makeSwapErrorRight({
+            message: message ?? 'Symbiosis quote request failed',
+            code: symbiosisErrorToTradeQuoteError(message),
+        }));
+    }
+    const { data: quote } = maybeQuote.unwrap();
+    if (!isSymbiosisRouteSupported({ quote, sellAsset })) {
+        return Err(makeSwapErrorRight({
+            message: 'No Symbiosis route through its own liquidity',
+            code: TradeQuoteError.NoRouteFound,
+        }));
+    }
+    // The quote must carry the fee we report, otherwise Symbiosis is not collecting it on this route
+    if (partnerAddress &&
+        !quote.fees.some(fee => fee.description === SYMBIOSIS_PARTNER_FEE_DESCRIPTION)) {
+        return Err(makeSwapErrorRight({
+            message: 'Symbiosis quote is missing the partner fee',
+            code: TradeQuoteError.InvalidResponse,
+        }));
+    }
+    const buyAmountAfterFeesCryptoBaseUnit = quote.tokenAmountOut.amount;
+    const protocolFees = getSymbiosisProtocolFees(quote.fees);
+    const buyAmountBeforeFeesCryptoBaseUnit = bn(buyAmountAfterFeesCryptoBaseUnit)
+        .plus(protocolFees[buyAsset.assetId]?.amountCryptoBaseUnit ?? 0)
+        .toFixed(0);
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const allowanceContract = isToken(sellAsset.assetId) ? quote.approveTo : '';
+    if (allowanceContract === undefined) {
+        return Err(makeSwapErrorRight({
+            message: 'Symbiosis returned no spender for a token sell',
+            code: TradeQuoteError.QueryFailed,
+        }));
+    }
+    return Ok({
+        tradeCommon: {
+            id: uuid(),
+            rate,
+            swapperName: SwapperName.Symbiosis,
+            affiliateBps: partnerAddress ? SYMBIOSIS_PARTNER_FEE_BPS : '0',
+            slippageTolerancePercentageDecimal: bn(slippageBps).div(10000).toString(),
+        },
+        stepCommon: {
+            allowanceContract,
+            rate,
+            buyAmountBeforeFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAsset,
+            sellAsset,
+            source: SwapperName.Symbiosis,
+            estimatedExecutionTimeMs: quote.estimatedTime * 1000,
+            // The fee accrues in sTokens on the Symbiosis chain - the buy asset figure is a display estimate
+            affiliateFee: partnerAddress
+                ? buildAffiliateFee({
+                    strategy: 'buy_asset',
+                    affiliateBps: SYMBIOSIS_PARTNER_FEE_BPS,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                    isEstimate: true,
+                })
+                : undefined,
+        },
+        protocolFees,
+        stepDataArgs: {
+            swapTx: quote,
+            sellAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            spenderAddress: allowanceContract,
+            tronFallbackEnergy: getSymbiosisTronFallbackEnergy(quote.labels),
+            from,
+            deps,
+        },
+    });
+};

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

@@ -0,0 +1,38 @@
+import type { AssetId, ChainId } from '@shapeshiftoss/caip';
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, TradeStatus } from '../../../types.js';
+import { TradeQuoteError } from '../../../types.js';
+import type { SymbiosisFee, SymbiosisQuoteResponse, SymbiosisToken, SymbiosisTxResponse } from './types.js';
+export declare const assertValidTrade: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Result<{
+    sellSymbiosisChainId: number;
+    buySymbiosisChainId: number;
+}, SwapErrorRight>;
+export declare const getSymbiosisTokenAddress: (asset: Asset) => string;
+export declare const getSymbiosisSlippageBps: (slippageTolerancePercentageDecimal: string) => number;
+export declare const getDefaultUserAddress: (chainId: ChainId) => string;
+export declare const getSymbiosisPartnerAddress: (affiliateBps: string) => Result<string | undefined, SwapErrorRight>;
+export declare const buildSymbiosisTronCallData: ({ functionSelector, data, }: {
+    functionSelector: string;
+    data: string;
+}) => string;
+export declare const getSymbiosisTronFallbackEnergy: (labels: string[]) => string;
+export declare const isSymbiosisRouteSupported: ({ quote, sellAsset, }: {
+    quote: SymbiosisQuoteResponse;
+    sellAsset: Asset;
+}) => boolean;
+export declare const getSymbiosisFeeAssetId: ({ chainId: symbiosisChainId, address, }: Pick<SymbiosisToken, 'chainId' | 'address'>) => AssetId | undefined;
+export declare const getSymbiosisProtocolFees: (fees: SymbiosisFee[]) => NonNullable<QuoteFeeData['protocolFees']>;
+export declare const symbiosisErrorToTradeQuoteError: (message: string | undefined) => TradeQuoteError;
+export declare const isTronSourceTxFailed: (tx: {
+    ret?: {
+        contractRet?: string;
+    }[];
+}) => boolean;
+export declare const getSymbiosisTradeStatus: ({ response, buySymbiosisChainId, }: {
+    response: SymbiosisTxResponse;
+    buySymbiosisChainId: number | undefined;
+}) => Pick<TradeStatus, 'status' | 'buyTxHash' | 'message'>;