@admin-jigsaw/jigsaw-sdk/dist/esm/test/JigsawClient.liquidation.test.js

Returns predefined data for Jigsaw platform and exposes functionality to retrieve the necessary data

import { describe, it, expect, vi, beforeEach } from "vitest";
import { JigsawClient } from "../index";
import { mainnet, sonic } from "viem/chains";
import { MOCK_HOLDING_ADDRESS, MOCK_STRATEGY_ADDRESS_1, } from "./utils/testClient";
// Mock the dependencies
vi.mock("../constants/chains");
vi.mock("../utils/protocols.utils", () => ({
    getProtocolByStrategy: vi.fn().mockReturnValue("AAVE"),
}));
vi.mock("../utils/pendle.utils", () => ({
    generatePendleRemoveLiquidityDataString: vi
        .fn()
        .mockResolvedValue("0xmockdata"),
    getPendleMarketByStrategy: vi.fn().mockReturnValue("0xmockmarket"),
}));
vi.mock("../lib/pendle", () => ({
    removeLiquiditySingleToken: vi
        .fn()
        .mockResolvedValue({ mockResponse: "data" }),
}));
describe("JigsawClient Liquidation Info", () => {
    let client;
    let mockReadContract;
    let mockMulticall;
    beforeEach(() => {
        client = new JigsawClient("http://localhost:8545", mainnet.id);
        mockReadContract = vi.fn();
        mockMulticall = vi.fn();
        client.client.readContract = mockReadContract;
        client.client.multicall = mockMulticall;
        // Mock getUserStrategies to return consistent results
        vi.spyOn(client, "getUserStrategies").mockResolvedValue([
            MOCK_STRATEGY_ADDRESS_1,
        ]);
    });
    describe("getUserLiquidationInfo", () => {
        it("should handle symbols with special characters in liquidation info", async () => {
            // Mock the multicall response for strategy info
            mockMulticall.mockResolvedValue([
                { result: [BigInt(0), BigInt(1000000)] }, // recipients result
                { result: "0x1234567890123456789012345678901234567890" }, // tokenIn result
            ]);
            const result = await client.getUserLiquidationInfo(MOCK_HOLDING_ADDRESS, "USD0++");
            expect(result.strategies).toEqual([MOCK_STRATEGY_ADDRESS_1]);
            expect(result.strategiesData).toHaveLength(1);
            expect(client.getUserStrategies).toHaveBeenCalledWith(MOCK_HOLDING_ADDRESS, "USD0++");
        });
        it("should handle USDC.e symbol for sonic chain", async () => {
            const sonicClient = new JigsawClient("http://localhost:8545", sonic.id);
            sonicClient.client.multicall = mockMulticall;
            vi.spyOn(sonicClient, "getUserStrategies").mockResolvedValue([
                MOCK_STRATEGY_ADDRESS_1,
            ]);
            mockMulticall.mockResolvedValue([
                { result: [BigInt(0), BigInt(1000000)] },
                { result: "0x1234567890123456789012345678901234567890" },
            ]);
            const result = await sonicClient.getUserLiquidationInfo(MOCK_HOLDING_ADDRESS, "USDC.e");
            expect(result.strategies).toEqual([MOCK_STRATEGY_ADDRESS_1]);
            expect(sonicClient.getUserStrategies).toHaveBeenCalledWith(MOCK_HOLDING_ADDRESS, "USDC.e");
        });
        it("should handle case insensitive symbols in liquidation info", async () => {
            mockMulticall.mockResolvedValue([
                { result: [BigInt(0), BigInt(1000000)] },
                { result: "0x1234567890123456789012345678901234567890" },
            ]);
            const result = await client.getUserLiquidationInfo(MOCK_HOLDING_ADDRESS, "usd0++");
            expect(result.strategies).toEqual([MOCK_STRATEGY_ADDRESS_1]);
            expect(client.getUserStrategies).toHaveBeenCalledWith(MOCK_HOLDING_ADDRESS, "usd0++");
        });
        it("should handle empty strategies array gracefully", async () => {
            vi.spyOn(client, "getUserStrategies").mockResolvedValue([]);
            const result = await client.getUserLiquidationInfo(MOCK_HOLDING_ADDRESS, "USD0++");
            expect(result.strategies).toEqual([]);
            expect(result.strategiesData).toEqual([]);
        });
        it("should pass through pendleSlippage parameter correctly", async () => {
            mockMulticall.mockResolvedValue([
                { result: [BigInt(0), BigInt(1000000)] },
                { result: "0x1234567890123456789012345678901234567890" },
            ]);
            const customSlippage = 0.02; // 2%
            await client.getUserLiquidationInfo(MOCK_HOLDING_ADDRESS, "USD0++", customSlippage);
            expect(client.getUserStrategies).toHaveBeenCalledWith(MOCK_HOLDING_ADDRESS, "USD0++");
        });
        it("should handle errors in strategy processing gracefully", async () => {
            vi.spyOn(client, "getUserStrategies").mockResolvedValue([
                MOCK_STRATEGY_ADDRESS_1,
            ]);
            mockMulticall.mockRejectedValue(new Error("Multicall failed"));
            const result = await client.getUserLiquidationInfo(MOCK_HOLDING_ADDRESS, "USD0++");
            expect(result.strategies).toEqual([MOCK_STRATEGY_ADDRESS_1]);
            expect(result.strategiesData).toEqual([
                "0x0000000000000000000000000000000000000000",
            ]); // zeroAddress for error case
        });
    });
});