@shapeshiftoss/swapper 20.2.0 → 20.4.0

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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSymbiosisStepData = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const utils_2 = require("../../../utils");
+const evm_1 = require("../../../utils/evm");
+const tron_1 = require("../../../utils/tron");
+const constants_1 = require("./constants");
+const helpers_1 = require("./helpers");
+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 = (0, utils_1.isToken)(sellAsset.assetId) ? '0' : sellAmountCryptoBaseUnit;
+    if (!(0, utils_1.bnOrZero)(swapTx.tx.value).eq(expectedValue)) {
+        return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getSymbiosisStepData'));
+    }
+    if (swapTx.tx.chainId !== constants_1.chainIdToSymbiosisChainId[sellAsset.chainId]) {
+        return (0, monads_1.Err)((0, utils_2.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((0, caip_1.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 (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+                    adapter,
+                    transactionData,
+                    from,
+                    supportsEIP1559,
+                    stateOverride,
+                }).catch(() => undefined);
+                const stepData = { networkFeeCryptoBaseUnit };
+                return (0, monads_1.Ok)(stepData);
+            }
+            try {
+                const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+                    adapter,
+                    transactionData,
+                    from,
+                    supportsEIP1559,
+                    stateOverride,
+                });
+                const stepData = { transactionData, networkFeeCryptoBaseUnit };
+                return (0, monads_1.Ok)(stepData);
+            }
+            catch (error) {
+                return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getSymbiosisStepData', error));
+            }
+        }
+        case 'tron': {
+            const { tx } = swapTx;
+            if (!tx.functionSelector)
+                return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getSymbiosisStepData'));
+            const adapter = deps.assertGetTronChainAdapter(sellAsset.chainId);
+            const call = {
+                to: tx.to,
+                data: (0, helpers_1.buildSymbiosisTronCallData)({ functionSelector: tx.functionSelector, data: tx.data }),
+                value: tx.value ?? '0',
+            };
+            if (type === 'rate') {
+                const networkFeeCryptoBaseUnit = await (0, tron_1.getTronContractCallFallbackFeeCryptoBaseUnit)({
+                    adapter,
+                    energy: tronFallbackEnergy,
+                    bandwidthBytes: chain_adapters_1.tron.getTronContractCallBandwidthBytes(call.data),
+                    contractAddress: call.to,
+                    fullEnergyOnShareLookupFailure: true,
+                }).catch(() => undefined);
+                const stepData = { networkFeeCryptoBaseUnit };
+                return (0, monads_1.Ok)(stepData);
+            }
+            try {
+                const stepData = {
+                    transactionData: { type: 'tron', ...call },
+                    networkFeeCryptoBaseUnit: await (0, tron_1.getTronContractCallNetworkFeeCryptoBaseUnit)({
+                        adapter,
+                        transactionData: call,
+                        from,
+                        sellAsset,
+                        sellAmountCryptoBaseUnit,
+                        spenderAddress,
+                        fallbackEnergy: tronFallbackEnergy,
+                    }),
+                };
+                return (0, monads_1.Ok)(stepData);
+            }
+            catch (error) {
+                return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getSymbiosisStepData', error));
+            }
+        }
+        default:
+            return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getSymbiosisStepData'));
+    }
+}
+exports.getSymbiosisStepData = getSymbiosisStepData;

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

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

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

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const caip_1 = require("@shapeshiftoss/caip");
+const vitest_1 = require("vitest");
+const types_1 = require("../../../types");
+const evm_1 = require("../../../utils/evm");
+const assets_1 = require("../../../utils/test-data/assets");
+const tron_1 = require("../../../utils/tron");
+const getSymbiosisStepData_1 = require("./getSymbiosisStepData");
+vitest_1.vi.mock('../../../utils/evm', () => ({
+    getEvmNetworkFeeCryptoBaseUnit: vitest_1.vi.fn(),
+}));
+vitest_1.vi.mock('../../../utils/tron', () => ({
+    getTronContractCallFallbackFeeCryptoBaseUnit: vitest_1.vi.fn(),
+    getTronContractCallNetworkFeeCryptoBaseUnit: vitest_1.vi.fn(),
+}));
+const TRX = {
+    ...assets_1.ETH,
+    assetId: caip_1.tronAssetId,
+    chainId: caip_1.tronChainId,
+    symbol: 'TRX',
+    precision: 6,
+};
+const ROUTER = '0x3743c756b64ECd0770f1d4f47696A73d2A46dcbe';
+const TRON_ROUTER = 'TPuaJ6gnYfE9gLUDFrbWbPx3tMnjG8max1';
+const FROM = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045';
+const TRON_FROM = 'TLa2f6VPqDgRE67v1736s7bJ8Ray5wYjU7';
+const deps = {
+    assertGetEvmChainAdapter: vitest_1.vi.fn(() => ({})),
+    assertGetTronChainAdapter: vitest_1.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: assets_1.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,
+};
+(0, vitest_1.describe)('getSymbiosisStepData', () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+    });
+    (0, vitest_1.describe)('evm', () => {
+        (0, vitest_1.it)('fails to build when a token sell carries native value', async () => {
+            const swapTx = {
+                type: 'evm',
+                tx: { ...evmSwapTx.tx, value: '300000000000000' },
+            };
+            const result = await (0, getSymbiosisStepData_1.getSymbiosisStepData)({
+                ...evmArgs,
+                swapTx,
+                type: 'quote',
+                input: quoteInput,
+            });
+            (0, vitest_1.expect)(result.unwrapErr().code).toBe(types_1.TradeQuoteError.InvalidResponse);
+            (0, vitest_1.expect)(evm_1.getEvmNetworkFeeCryptoBaseUnit).not.toHaveBeenCalled();
+        });
+        (0, vitest_1.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 (0, getSymbiosisStepData_1.getSymbiosisStepData)({
+                ...evmArgs,
+                swapTx,
+                sellAsset: assets_1.ETH_ARBITRUM,
+                sellAmountCryptoBaseUnit: '50000000000000000',
+                type: 'quote',
+                input: quoteInput,
+            });
+            (0, vitest_1.expect)(result.unwrapErr().code).toBe(types_1.TradeQuoteError.InvalidResponse);
+            (0, vitest_1.expect)(evm_1.getEvmNetworkFeeCryptoBaseUnit).not.toHaveBeenCalled();
+        });
+        (0, vitest_1.it)('fails to build when the payload is for another chain', async () => {
+            const swapTx = { type: 'evm', tx: { ...evmSwapTx.tx, chainId: 1 } };
+            const result = await (0, getSymbiosisStepData_1.getSymbiosisStepData)({
+                ...evmArgs,
+                swapTx,
+                type: 'quote',
+                input: quoteInput,
+            });
+            (0, vitest_1.expect)(result.unwrapErr().code).toBe(types_1.TradeQuoteError.InvalidResponse);
+            (0, vitest_1.expect)(evm_1.getEvmNetworkFeeCryptoBaseUnit).not.toHaveBeenCalled();
+        });
+        (0, vitest_1.it)('builds a native sell whose value is exactly the sell amount', async () => {
+            vitest_1.vi.mocked(evm_1.getEvmNetworkFeeCryptoBaseUnit).mockResolvedValue('1234');
+            const swapTx = {
+                type: 'evm',
+                tx: { ...evmSwapTx.tx, value: '50000000000000000' },
+            };
+            const result = await (0, getSymbiosisStepData_1.getSymbiosisStepData)({
+                ...evmArgs,
+                swapTx,
+                sellAsset: assets_1.ETH_ARBITRUM,
+                sellAmountCryptoBaseUnit: '50000000000000000',
+                type: 'quote',
+                input: quoteInput,
+            });
+            (0, vitest_1.expect)(result.isOk()).toBe(true);
+        });
+    });
+    (0, vitest_1.describe)('tron', () => {
+        const expectedCall = { to: TRON_ROUTER, data: '0xa11b11980020', value: '500000000' };
+        (0, vitest_1.it)('assembles the contract call and prices it for a quote', async () => {
+            vitest_1.vi.mocked(tron_1.getTronContractCallNetworkFeeCryptoBaseUnit).mockResolvedValue('45000000');
+            const result = await (0, getSymbiosisStepData_1.getSymbiosisStepData)({ ...tronArgs, type: 'quote', input: quoteInput });
+            (0, vitest_1.expect)(result.unwrap()).toEqual({
+                transactionData: { type: 'tron', ...expectedCall },
+                networkFeeCryptoBaseUnit: '45000000',
+            });
+            (0, vitest_1.expect)(tron_1.getTronContractCallNetworkFeeCryptoBaseUnit).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+                transactionData: expectedCall,
+                from: TRON_FROM,
+                spenderAddress: '',
+                fallbackEnergy: '580000',
+            }));
+        });
+        (0, vitest_1.it)('fails to build when the response has no function selector', async () => {
+            const swapTx = {
+                type: 'tron',
+                tx: { ...tronSwapTx.tx, functionSelector: undefined },
+            };
+            const result = await (0, getSymbiosisStepData_1.getSymbiosisStepData)({
+                ...tronArgs,
+                swapTx,
+                type: 'quote',
+                input: quoteInput,
+            });
+            (0, vitest_1.expect)(result.unwrapErr().code).toBe(types_1.TradeQuoteError.InvalidResponse);
+            (0, vitest_1.expect)(tron_1.getTronContractCallNetworkFeeCryptoBaseUnit).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/cjs/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';
+import type { GetSymbiosisStepDataArgs } from './getSymbiosisStepData';
+import type { SymbiosisTradeQuoteInput, SymbiosisTradeRateInput } from './types';
+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/cjs/swappers/SymbiosisSwapper/utils/getSymbiosisTradeContext.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSymbiosisTradeContext = void 0;
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const axios_1 = __importDefault(require("axios"));
+const uuid_1 = require("uuid");
+const constants_1 = require("../../../constants");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const affiliateFee_1 = require("../../../utils/affiliateFee");
+const constants_2 = require("./constants");
+const helpers_1 = require("./helpers");
+const symbiosisService_1 = require("./symbiosisService");
+const getSymbiosisTradeContext = async ({ input, deps, from, to, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const assertion = (0, helpers_1.assertValidTrade)({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return (0, monads_1.Err)(assertion.unwrapErr());
+    const { sellSymbiosisChainId, buySymbiosisChainId } = assertion.unwrap();
+    const slippageBps = (0, helpers_1.getSymbiosisSlippageBps)(input.slippageTolerancePercentageDecimal ??
+        (0, constants_1.getDefaultSlippageDecimalPercentageForSwapper)(types_1.SwapperName.Symbiosis));
+    const maybePartnerAddress = (0, helpers_1.getSymbiosisPartnerAddress)(affiliateBps);
+    if (maybePartnerAddress.isErr())
+        return (0, monads_1.Err)(maybePartnerAddress.unwrapErr());
+    const partnerAddress = maybePartnerAddress.unwrap();
+    const request = {
+        tokenAmountIn: {
+            chainId: sellSymbiosisChainId,
+            address: (0, helpers_1.getSymbiosisTokenAddress)(sellAsset),
+            decimals: sellAsset.precision,
+            amount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        },
+        tokenOut: {
+            chainId: buySymbiosisChainId,
+            address: (0, helpers_1.getSymbiosisTokenAddress)(buyAsset),
+            decimals: buyAsset.precision,
+        },
+        from,
+        to,
+        slippage: slippageBps,
+        disabledProviders: constants_2.SYMBIOSIS_DISABLED_PROVIDERS,
+        partnerAddress,
+    };
+    const maybeQuote = await symbiosisService_1.symbiosisService.post(`${deps.config.VITE_SYMBIOSIS_API_URL}/v2/quote`, request);
+    if (maybeQuote.isErr()) {
+        const { cause } = maybeQuote.unwrapErr();
+        if (!axios_1.default.isAxiosError(cause)) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: 'Unknown error',
+                code: types_1.TradeQuoteError.UnknownError,
+                cause,
+            }));
+        }
+        if (cause.response?.status === 429) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: 'Symbiosis rate limit exceeded',
+                code: types_1.TradeQuoteError.RateLimitExceeded,
+            }));
+        }
+        const message = cause.response?.data?.message;
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: message ?? 'Symbiosis quote request failed',
+            code: (0, helpers_1.symbiosisErrorToTradeQuoteError)(message),
+        }));
+    }
+    const { data: quote } = maybeQuote.unwrap();
+    if (!(0, helpers_1.isSymbiosisRouteSupported)({ quote, sellAsset })) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'No Symbiosis route through its own liquidity',
+            code: types_1.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 === constants_2.SYMBIOSIS_PARTNER_FEE_DESCRIPTION)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'Symbiosis quote is missing the partner fee',
+            code: types_1.TradeQuoteError.InvalidResponse,
+        }));
+    }
+    const buyAmountAfterFeesCryptoBaseUnit = quote.tokenAmountOut.amount;
+    const protocolFees = (0, helpers_1.getSymbiosisProtocolFees)(quote.fees);
+    const buyAmountBeforeFeesCryptoBaseUnit = (0, utils_1.bn)(buyAmountAfterFeesCryptoBaseUnit)
+        .plus(protocolFees[buyAsset.assetId]?.amountCryptoBaseUnit ?? 0)
+        .toFixed(0);
+    const rate = (0, utils_2.getInputOutputRate)({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const allowanceContract = (0, utils_1.isToken)(sellAsset.assetId) ? quote.approveTo : '';
+    if (allowanceContract === undefined) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'Symbiosis returned no spender for a token sell',
+            code: types_1.TradeQuoteError.QueryFailed,
+        }));
+    }
+    return (0, monads_1.Ok)({
+        tradeCommon: {
+            id: (0, uuid_1.v4)(),
+            rate,
+            swapperName: types_1.SwapperName.Symbiosis,
+            affiliateBps: partnerAddress ? constants_2.SYMBIOSIS_PARTNER_FEE_BPS : '0',
+            slippageTolerancePercentageDecimal: (0, utils_1.bn)(slippageBps).div(10000).toString(),
+        },
+        stepCommon: {
+            allowanceContract,
+            rate,
+            buyAmountBeforeFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAsset,
+            sellAsset,
+            source: types_1.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
+                ? (0, affiliateFee_1.buildAffiliateFee)({
+                    strategy: 'buy_asset',
+                    affiliateBps: constants_2.SYMBIOSIS_PARTNER_FEE_BPS,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                    isEstimate: true,
+                })
+                : undefined,
+        },
+        protocolFees,
+        stepDataArgs: {
+            swapTx: quote,
+            sellAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            spenderAddress: allowanceContract,
+            tronFallbackEnergy: (0, helpers_1.getSymbiosisTronFallbackEnergy)(quote.labels),
+            from,
+            deps,
+        },
+    });
+};
+exports.getSymbiosisTradeContext = getSymbiosisTradeContext;

package/dist/cjs/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';
+import { TradeQuoteError } from '../../../types';
+import type { SymbiosisFee, SymbiosisQuoteResponse, SymbiosisToken, SymbiosisTxResponse } from './types';
+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'>;

package/dist/cjs/swappers/SymbiosisSwapper/utils/helpers.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSymbiosisTradeStatus = exports.isTronSourceTxFailed = exports.symbiosisErrorToTradeQuoteError = exports.getSymbiosisProtocolFees = exports.getSymbiosisFeeAssetId = exports.isSymbiosisRouteSupported = exports.getSymbiosisTronFallbackEnergy = exports.buildSymbiosisTronCallData = exports.getSymbiosisPartnerAddress = exports.getDefaultUserAddress = exports.getSymbiosisSlippageBps = exports.getSymbiosisTokenAddress = exports.assertValidTrade = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const unchained_client_1 = require("@shapeshiftoss/unchained-client");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const viem_1 = require("viem");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const constants_1 = require("./constants");
+const types_2 = require("./types");
+const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    const sellSymbiosisChainId = constants_1.chainIdToSymbiosisChainId[sellAsset.chainId];
+    const buySymbiosisChainId = constants_1.chainIdToSymbiosisChainId[buyAsset.chainId];
+    if (sellSymbiosisChainId === undefined) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `Sell asset chain '${sellAsset.chainId}' not supported by Symbiosis`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    if (buySymbiosisChainId === undefined) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `Buy asset chain '${buyAsset.chainId}' not supported by Symbiosis`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    if (sellAsset.chainId === buyAsset.chainId) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'Symbiosis same-chain swaps are not supported',
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    return (0, monads_1.Ok)({ sellSymbiosisChainId, buySymbiosisChainId });
+};
+exports.assertValidTrade = assertValidTrade;
+const getSymbiosisTokenAddress = (asset) => {
+    if (!(0, utils_1.isToken)(asset.assetId))
+        return '';
+    const { assetReference } = (0, caip_1.fromAssetId)(asset.assetId);
+    if (asset.chainId === caip_1.tronChainId)
+        return chain_adapters_1.tron.toTronHex(assetReference);
+    return (0, viem_1.getAddress)(assetReference);
+};
+exports.getSymbiosisTokenAddress = getSymbiosisTokenAddress;
+const getSymbiosisSlippageBps = (slippageTolerancePercentageDecimal) => {
+    const bps = Math.round((0, utils_1.bnOrZero)(slippageTolerancePercentageDecimal).times(10000).toNumber());
+    return Math.min(Math.max(bps, constants_1.SYMBIOSIS_MIN_SLIPPAGE_BPS), constants_1.SYMBIOSIS_MAX_SLIPPAGE_BPS);
+};
+exports.getSymbiosisSlippageBps = getSymbiosisSlippageBps;
+const getDefaultUserAddress = (chainId) => chainId === caip_1.tronChainId ? constants_1.DEFAULT_SYMBIOSIS_TRON_USER_ADDRESS : constants_1.DEFAULT_SYMBIOSIS_EVM_USER_ADDRESS;
+exports.getDefaultUserAddress = getDefaultUserAddress;
+// Symbiosis fixes the partner rate on its side, so only a fee-free swap or the registered rate can be honored
+const getSymbiosisPartnerAddress = (affiliateBps) => {
+    const requestedBps = (0, utils_1.bnOrZero)(affiliateBps);
+    if (requestedBps.isZero())
+        return (0, monads_1.Ok)(undefined);
+    if (requestedBps.eq(constants_1.SYMBIOSIS_PARTNER_FEE_BPS))
+        return (0, monads_1.Ok)(constants_1.SYMBIOSIS_PARTNER_ADDRESS);
+    return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+        message: `Symbiosis only supports a ${constants_1.SYMBIOSIS_PARTNER_FEE_BPS} bps affiliate fee, got ${affiliateBps}`,
+        code: types_1.TradeQuoteError.UnsupportedTradePair,
+    }));
+};
+exports.getSymbiosisPartnerAddress = getSymbiosisPartnerAddress;
+// Symbiosis returns the function signature and its encoded parameters separately
+const buildSymbiosisTronCallData = ({ functionSelector, data, }) => {
+    const selector = (0, viem_1.keccak256)((0, viem_1.toHex)(functionSelector)).slice(0, 10);
+    const parameters = data.startsWith('0x') ? data.slice(2) : data;
+    return `${selector}${parameters}`;
+};
+exports.buildSymbiosisTronCallData = buildSymbiosisTronCallData;
+const getSymbiosisTronFallbackEnergy = (labels) => labels.includes(constants_1.SYMBIOSIS_SRC_CHAIN_SWAP_LABEL)
+    ? constants_1.SYMBIOSIS_TRON_SOURCE_SWAP_ENERGY
+    : constants_1.SYMBIOSIS_TRON_BRIDGE_ENERGY;
+exports.getSymbiosisTronFallbackEnergy = getSymbiosisTronFallbackEnergy;
+const isSymbiosisRouteSupported = ({ quote, sellAsset, }) => {
+    if (quote.kind !== constants_1.SYMBIOSIS_CROSSCHAIN_SWAP_KIND)
+        return false;
+    if (quote.labels.includes(constants_1.SYMBIOSIS_PARTNER_SWAP_LABEL))
+        return false;
+    if (quote.labels.includes(constants_1.SYMBIOSIS_SEMI_CENTRALIZED_LABEL))
+        return false;
+    const expectedType = sellAsset.chainId === caip_1.tronChainId ? 'tron' : 'evm';
+    return quote.type === expectedType;
+};
+exports.isSymbiosisRouteSupported = isSymbiosisRouteSupported;
+const getSymbiosisFeeAssetId = ({ chainId: symbiosisChainId, address, }) => {
+    const chainId = constants_1.symbiosisChainIdToChainId[symbiosisChainId];
+    if (!chainId)
+        return;
+    if (!address)
+        return (0, utils_1.chainIdToFeeAssetId)(chainId);
+    if (chainId === caip_1.tronChainId) {
+        return (0, caip_1.toAssetId)({
+            chainId,
+            assetNamespace: caip_1.ASSET_NAMESPACE.trc20,
+            assetReference: chain_adapters_1.tron.toTronBase58(address),
+        });
+    }
+    return (0, caip_1.toAssetId)({
+        chainId,
+        assetNamespace: caip_1.ASSET_NAMESPACE.erc20,
+        assetReference: address.toLowerCase(),
+    });
+};
+exports.getSymbiosisFeeAssetId = getSymbiosisFeeAssetId;
+// Fees on the Symbiosis host chain are charged in sTokens we have no asset for - they are already net of the buy amount
+const getSymbiosisProtocolFees = (fees) => fees.reduce((acc, { value }) => {
+    const assetId = (0, exports.getSymbiosisFeeAssetId)(value);
+    const chainId = constants_1.symbiosisChainIdToChainId[value.chainId];
+    if (!assetId || !chainId)
+        return acc;
+    acc[assetId] = {
+        amountCryptoBaseUnit: (0, utils_1.bnOrZero)(acc[assetId]?.amountCryptoBaseUnit)
+            .plus(value.amount)
+            .toFixed(0),
+        asset: { symbol: value.symbol, chainId, precision: value.decimals },
+        requiresBalance: false,
+    };
+    return acc;
+}, {});
+exports.getSymbiosisProtocolFees = getSymbiosisProtocolFees;
+const symbiosisErrorToTradeQuoteError = (message) => {
+    if (message?.startsWith('Amount is too low'))
+        return types_1.TradeQuoteError.SellAmountBelowTradeFee;
+    if (message === 'This swap is not available')
+        return types_1.TradeQuoteError.NoRouteFound;
+    return types_1.TradeQuoteError.QueryFailed;
+};
+exports.symbiosisErrorToTradeQuoteError = symbiosisErrorToTradeQuoteError;
+// A mined Tron call that did not succeed (REVERT, OUT_OF_ENERGY, ...) never reaches Symbiosis, which answers not found for it
+const isTronSourceTxFailed = (tx) => {
+    const contractRet = tx.ret?.[0]?.contractRet;
+    return contractRet !== undefined && contractRet !== 'SUCCESS';
+};
+exports.isTronSourceTxFailed = isTronSourceTxFailed;
+const getSymbiosisTradeStatus = ({ response, buySymbiosisChainId, }) => {
+    const { status, tx, transitTokenSent } = response;
+    switch (status.code) {
+        case types_2.SymbiosisStatusCode.Success: {
+            // Until the operation is indexed, Symbiosis answers Success for the plain source transaction
+            if (tx?.chainId !== buySymbiosisChainId) {
+                return { status: unchained_client_1.TxStatus.Pending, buyTxHash: undefined, message: undefined };
+            }
+            const message = transitTokenSent
+                ? `Received ${(0, utils_1.bn)(transitTokenSent.amount)
+                    .shiftedBy(-transitTokenSent.decimals)
+                    .toFixed()} ${transitTokenSent.symbol} instead of the buy asset`
+                : undefined;
+            return { status: unchained_client_1.TxStatus.Confirmed, buyTxHash: tx?.hash, message };
+        }
+        case types_2.SymbiosisStatusCode.Pending:
+            return { status: unchained_client_1.TxStatus.Pending, buyTxHash: undefined, message: undefined };
+        case types_2.SymbiosisStatusCode.Stuck:
+            return {
+                status: unchained_client_1.TxStatus.Pending,
+                buyTxHash: undefined,
+                message: 'Swap is stuck and is being reverted by Symbiosis',
+            };
+        case types_2.SymbiosisStatusCode.Reverted:
+            return {
+                status: unchained_client_1.TxStatus.Failed,
+                buyTxHash: undefined,
+                message: 'Swap was reverted by Symbiosis',
+            };
+        default:
+            return { status: unchained_client_1.TxStatus.Unknown, buyTxHash: undefined, message: undefined };
+    }
+};
+exports.getSymbiosisTradeStatus = getSymbiosisTradeStatus;

package/dist/cjs/swappers/SymbiosisSwapper/utils/helpers.test.d.ts

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