@kasufinance/kasu-sdk 2.6.0 → 2.7.0

package/src/facade/config.test.ts

@@ -1,265 +0,0 @@
-import { providers, Wallet } from 'ethers';
-
-import { SdkConfig } from '../sdk-config';
-
-import { CHAIN_CONFIGS } from './chain-configs';
-import { Kasu } from './kasu';
-import { ChainConfigEntry } from './types';
-
-// Pure config assertions — no network, unlike `facade.test.ts`.
-
-const BASE_CONTRACTS = CHAIN_CONFIGS.base.contracts;
-
-/** A signer with a provider attached, offline — nothing here sends anything. */
-function signer(): Wallet {
-    return Wallet.createRandom().connect(
-        new providers.StaticJsonRpcProvider(
-            CHAIN_CONFIGS.base.rpcUrls[0],
-            CHAIN_CONFIGS.base.chainId,
-        ),
-    );
-}
-
-describe('SdkConfig — UNUSED_LENDING_POOL_IDS normalisation', () => {
-    it("turns an empty exclusion list into the [''] sentinel", () => {
-        // `id_not_in: []` matches NOTHING in the subgraph: on Base it returns
-        // 0 pools where `['']` returns all 9 (verified live 2026-09-04).
-        const config = new SdkConfig({
-            subgraphUrl: 'https://example.invalid/subgraph',
-            contracts: BASE_CONTRACTS,
-            UNUSED_LENDING_POOL_IDS: [],
-        });
-        expect(config.UNUSED_LENDING_POOL_IDS).toEqual(['']);
-    });
-
-    it('leaves a caller-supplied exclusion list untouched', () => {
-        const config = new SdkConfig({
-            subgraphUrl: 'https://example.invalid/subgraph',
-            contracts: BASE_CONTRACTS,
-            UNUSED_LENDING_POOL_IDS: ['0xdead'],
-        });
-        expect(config.UNUSED_LENDING_POOL_IDS).toEqual(['0xdead']);
-    });
-
-    it('leaves a sentinel a consumer already passes untouched', () => {
-        // kasu-ui passes [''], kasu-mobile passes the zero address.
-        const zeroAddress = '0x0000000000000000000000000000000000000000';
-        for (const sentinel of [[''], [zeroAddress]]) {
-            const config = new SdkConfig({
-                subgraphUrl: 'https://example.invalid/subgraph',
-                contracts: BASE_CONTRACTS,
-                UNUSED_LENDING_POOL_IDS: sentinel,
-            });
-            expect(config.UNUSED_LENDING_POOL_IDS).toEqual(sentinel);
-        }
-    });
-});
-
-describe('CHAIN_CONFIGS — stable asset', () => {
-    it('gives every chain exactly one stable asset', () => {
-        for (const [chain, config] of Object.entries(CHAIN_CONFIGS)) {
-            expect(config.stableAsset.address).toMatch(/^0x[0-9a-fA-F]{40}$/);
-            expect(config.stableAsset.symbol.length).toBeGreaterThan(0);
-            expect(config.stableAsset.decimals).toBeGreaterThan(0);
-            expect(config.stableAsset.currencyCode).toMatch(/^[A-Z]{3}$/);
-            expect(chain).toBeTruthy();
-        }
-    });
-
-    it('carries the live token per deployment', () => {
-        expect(CHAIN_CONFIGS.base.stableAsset).toEqual({
-            address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
-            symbol: 'USDC',
-            name: 'USD Coin',
-            decimals: 6,
-            currencyCode: 'USD',
-        });
-        expect(CHAIN_CONFIGS.xdc.stableAsset.symbol).toBe('AUDD');
-        expect(CHAIN_CONFIGS.xdc.stableAsset.currencyCode).toBe('AUD');
-        expect(CHAIN_CONFIGS['xdc-usdc'].stableAsset.symbol).toBe('USDC');
-        expect(CHAIN_CONFIGS.plume.stableAsset.symbol).toBe('pUSD');
-    });
-});
-
-describe('CHAIN_CONFIGS — rpcUrls', () => {
-    it('gives every live deployment at least one default endpoint', () => {
-        for (const chain of ['base', 'xdc', 'xdc-usdc'] as const) {
-            expect(CHAIN_CONFIGS[chain].rpcUrls.length).toBeGreaterThan(0);
-            expect(CHAIN_CONFIGS[chain].retired).toBeUndefined();
-        }
-    });
-
-    it('never lists an XDC endpoint that fails CORS preflight', () => {
-        // `rpc.xdc.org` / `erpc.xdc.org` answer OPTIONS without
-        // `access-control-allow-origin`, so a browser call hangs. House rule.
-        for (const config of Object.values(CHAIN_CONFIGS)) {
-            for (const url of config.rpcUrls) {
-                expect(url).not.toContain('rpc.xdc.org');
-                expect(url).not.toContain('erpc.xdc.org');
-            }
-        }
-    });
-
-    it('marks the retired deployment and leaves it without a default RPC', () => {
-        expect(CHAIN_CONFIGS.plume.retired).toBe(true);
-        expect(CHAIN_CONFIGS.plume.rpcUrls).toEqual([]);
-    });
-});
-
-describe('Kasu — read-only create and connect', () => {
-    it('creates a read-only instance with no signerOrProvider', () => {
-        const kasu = Kasu.create({ chain: 'base' });
-        expect(kasu.isReadOnly).toBe(true);
-        expect(kasu.provider).toBeInstanceOf(providers.StaticJsonRpcProvider);
-    });
-
-    it('uses rpcUrls[0] and the config chain id, with no network detection', () => {
-        const kasu = Kasu.create({ chain: 'base' });
-        const provider = kasu.provider as providers.StaticJsonRpcProvider;
-        expect(provider.connection.url).toBe(CHAIN_CONFIGS.base.rpcUrls[0]);
-        expect(provider.network.chainId).toBe(CHAIN_CONFIGS.base.chainId);
-    });
-
-    it('refuses a read-only create on a retired chain with no default RPC', () => {
-        expect(() => Kasu.create({ chain: 'plume' })).toThrow(
-            'Kasu.create: chain "plume" has no default RPC (retired); pass signerOrProvider',
-        );
-    });
-
-    it('still accepts an explicit provider for the retired chain', () => {
-        const provider = new providers.StaticJsonRpcProvider(
-            'https://example.invalid/plume',
-            CHAIN_CONFIGS.plume.chainId,
-        );
-        const kasu = Kasu.create({ chain: 'plume', signerOrProvider: provider });
-        expect(kasu.isReadOnly).toBe(true);
-        expect(kasu.provider).toBe(provider);
-    });
-
-    it('is writable when created from a signer', () => {
-        const kasu = Kasu.create({ chain: 'base', signerOrProvider: signer() });
-        expect(kasu.isReadOnly).toBe(false);
-    });
-
-    it('connect returns a NEW writable instance, leaving the original read-only', () => {
-        const readOnly = Kasu.create({ chain: 'base' });
-        const connected = readOnly.connect(signer());
-        expect(connected).not.toBe(readOnly);
-        expect(connected.isReadOnly).toBe(false);
-        expect(readOnly.isReadOnly).toBe(true);
-    });
-
-    it('connect keeps the chain config and the configOverrides', () => {
-        const readOnly = Kasu.create({
-            chain: 'base',
-            configOverrides: { UNUSED_LENDING_POOL_IDS: ['0xhidden'] },
-        });
-        const connected = readOnly.connect(signer());
-        expect(connected.chainConfig).toBe(readOnly.chainConfig);
-        const configOf = (kasu: Kasu): SdkConfig =>
-            (kasu.services.DataService as unknown as { _kasuConfig: SdkConfig })
-                ._kasuConfig;
-        expect(configOf(connected).UNUSED_LENDING_POOL_IDS).toEqual([
-            '0xhidden',
-        ]);
-    });
-
-    it('exposes the signer’s own provider on a connected instance', () => {
-        const wallet = signer();
-        const kasu = Kasu.create({ chain: 'base', signerOrProvider: wallet });
-        expect(kasu.provider).toBe(wallet.provider);
-    });
-
-    it('throws rather than returning undefined for a provider-less signer', () => {
-        const kasu = Kasu.create({
-            chain: 'base',
-            signerOrProvider: Wallet.createRandom(),
-        });
-        expect(() => kasu.provider).toThrow('has no provider attached');
-    });
-});
-
-describe('DepositsFacade — read-only writes', () => {
-    const readOnly = (): Kasu => Kasu.create({ chain: 'base' });
-    const READ_ONLY_MESSAGE =
-        'Kasu: this instance is read-only; call kasu.connect(signer) first';
-
-    it('refuses deposit before touching the contract', async () => {
-        await expect(
-            readOnly().deposits.deposit({
-                poolId: '0xpool',
-                trancheId: '0xtranche',
-                amount: 1,
-                kycSignature: { blockExpiration: 0, signature: '0x' },
-            }),
-        ).rejects.toThrow(READ_ONLY_MESSAGE);
-    });
-
-    it('refuses withdraw', async () => {
-        await expect(
-            readOnly().deposits.withdraw({
-                poolId: '0xpool',
-                trancheId: '0xtranche',
-                amount: 1,
-            }),
-        ).rejects.toThrow(READ_ONLY_MESSAGE);
-    });
-
-    it('refuses withdrawMax', async () => {
-        await expect(
-            readOnly().deposits.withdrawMax('0xpool', '0xtranche', '0xuser'),
-        ).rejects.toThrow(READ_ONLY_MESSAGE);
-    });
-
-    it('lets a connected instance past the guard', () => {
-        const connected = readOnly().connect(signer());
-        // Reaches the contract call (and fails there on a fake address) rather
-        // than being refused up front. Probing the guard directly keeps the
-        // assertion off the network.
-        const guard = connected.deposits as unknown as {
-            assertWritable(): void;
-        };
-        expect(() => {
-            guard.assertWritable();
-        }).not.toThrow();
-    });
-});
-
-describe('Kasu.create — a ChainConfigEntry written before 2.5.0', () => {
-    // kasu-app-admin hand-builds one of these for base-sepolia. TypeScript will
-    // ask it for `stableAsset` and `rpcUrls` on bump; the runtime must not
-    // crash first.
-    const legacy = (): ChainConfigEntry =>
-        ({
-            chainId: 84532,
-            name: 'base-sepolia',
-            isLiteDeployment: false,
-            contracts: BASE_CONTRACTS,
-            subgraphUrl: 'https://example.invalid/subgraph',
-            // Non-empty: `SdkConfig` documents `directusUrl` as optional, but
-            // `createDirectus('')` throws `TypeError: Invalid URL`. Pre-existing,
-            // and unrelated to what this test covers.
-            directusUrl: 'https://example.invalid/directus/',
-            unusedPoolIds: [''],
-        }) as unknown as ChainConfigEntry;
-
-    it('constructs with an explicit provider and falls back to 6 decimals', () => {
-        const kasu = Kasu.create({
-            chain: legacy(),
-            signerOrProvider: new providers.StaticJsonRpcProvider(
-                'https://example.invalid/rpc',
-                84532,
-            ),
-        });
-        const config = (
-            kasu.services.DataService as unknown as { _kasuConfig: SdkConfig }
-        )._kasuConfig;
-        expect(config.stableAssetDecimals).toBe(6);
-    });
-
-    it('refuses a read-only create with the same message a retired chain gives', () => {
-        expect(() => Kasu.create({ chain: legacy() })).toThrow(
-            'Kasu.create: chain "base-sepolia" has no default RPC (retired); pass signerOrProvider',
-        );
-    });
-});

package/src/facade/facade.test.ts

@@ -1,374 +0,0 @@
-/**
- * Offline facade specs — a mock provider and pure helpers, no network. Moved
- * here from `src/tests/` so it runs beside the code it covers, and so the
- * opt-in `LIVE_TESTS` gate on `src/tests/` does not take it out of CI.
- */
-import { DataService } from '../services/DataService/data-service';
-import { NO_DIRECTUS_URL_MESSAGE } from '../services/DataService/directus-client';
-import { Portfolio } from '../services/Portfolio/portfolio';
-import { UserRequestStatus } from '../services/UserLending/subgraph-types';
-import { UserRequest } from '../services/UserLending/types';
-import { UserLending } from '../services/UserLending/user-lending';
-
-import { CHAIN_CONFIGS } from './chain-configs';
-import { DepositsFacade } from './deposits';
-import { Kasu } from './kasu';
-import { StrategiesFacade } from './strategies';
-import { PortfolioFacade } from './user-portfolio';
-
-// ---------------------------------------------------------------------------
-// Chain configs
-// ---------------------------------------------------------------------------
-
-describe('CHAIN_CONFIGS', () => {
-    it('should have base, xdc, and plume entries', () => {
-        expect(CHAIN_CONFIGS).toHaveProperty('base');
-        expect(CHAIN_CONFIGS).toHaveProperty('xdc');
-        expect(CHAIN_CONFIGS).toHaveProperty('plume');
-    });
-
-    it('base should be a full deployment', () => {
-        const base = CHAIN_CONFIGS.base;
-        expect(base.chainId).toBe(8453);
-        expect(base.isLiteDeployment).toBe(false);
-        expect(base.contracts.KSUToken).toBeDefined();
-        expect(base.contracts.KasuNFTs).toBeDefined();
-    });
-
-    it('xdc should be a lite deployment without KSU token', () => {
-        const xdc = CHAIN_CONFIGS.xdc;
-        expect(xdc.chainId).toBe(50);
-        expect(xdc.isLiteDeployment).toBe(true);
-        expect(xdc.contracts.KSUToken).toBeUndefined();
-        expect(xdc.contracts.KasuNFTs).toBeUndefined();
-    });
-
-    it('plume should be a lite deployment', () => {
-        const plume = CHAIN_CONFIGS.plume;
-        expect(plume.chainId).toBe(98866);
-        expect(plume.isLiteDeployment).toBe(true);
-    });
-
-    it('all chains should have required contract addresses', () => {
-        for (const [, config] of Object.entries(CHAIN_CONFIGS)) {
-            expect(config.contracts.LendingPoolManager).toBeDefined();
-            expect(config.contracts.UserManager).toBeDefined();
-            expect(config.contracts.KasuAllowList).toBeDefined();
-            expect(config.contracts.SystemVariables).toBeDefined();
-            expect(config.subgraphUrl).toContain('goldsky.com');
-        }
-    });
-
-    it('plume points at the LEGACY goldsky project its frozen history is on', () => {
-        // Plume was indexed before the live chains moved to the current
-        // project; the same path under that project returns HTTP 404, so the
-        // retired deployment's history is only readable at this spelling —
-        // note the `/gn` suffix the current project's URLs do not carry.
-        const projectOf = (url: string): string => url.split('/')[5] ?? '';
-        expect(projectOf(CHAIN_CONFIGS.plume.subgraphUrl)).not.toBe(
-            projectOf(CHAIN_CONFIGS.base.subgraphUrl),
-        );
-        expect(CHAIN_CONFIGS.plume.subgraphUrl.endsWith('/gn')).toBe(true);
-    });
-
-    it('xdc should have poolMetadataMapping', () => {
-        const mapping = CHAIN_CONFIGS.xdc.poolMetadataMapping;
-        expect(mapping).toBeDefined();
-        expect(Object.keys(mapping ?? {}).length).toBeGreaterThan(0);
-    });
-});
-
-// ---------------------------------------------------------------------------
-// Kasu.create()
-// ---------------------------------------------------------------------------
-
-describe('Kasu.create()', () => {
-    // Mock provider — enough to construct the SDK without network calls
-    const mockProvider = {
-        getNetwork: jest.fn().mockResolvedValue({ chainId: 8453, name: 'base' }),
-        call: jest.fn(),
-        estimateGas: jest.fn(),
-        getBlockNumber: jest.fn(),
-        getBlock: jest.fn(),
-        getTransaction: jest.fn(),
-        getTransactionReceipt: jest.fn(),
-        getLogs: jest.fn(),
-        on: jest.fn(),
-        once: jest.fn(),
-        off: jest.fn(),
-        removeAllListeners: jest.fn(),
-        _isProvider: true,
-    };
-
-    it('should create an instance from a chain name', () => {
-        const kasu = Kasu.create({
-            chain: 'base',
-            signerOrProvider: mockProvider as never,
-        });
-
-        expect(kasu).toBeInstanceOf(Kasu);
-        expect(kasu.strategies).toBeInstanceOf(StrategiesFacade);
-        expect(kasu.deposits).toBeInstanceOf(DepositsFacade);
-        expect(kasu.portfolio).toBeInstanceOf(PortfolioFacade);
-    });
-
-    it('should expose chainConfig for the selected chain', () => {
-        const kasu = Kasu.create({
-            chain: 'xdc',
-            signerOrProvider: mockProvider as never,
-        });
-
-        expect(kasu.chainConfig.chainId).toBe(50);
-        expect(kasu.isLiteDeployment).toBe(true);
-    });
-
-    it('should accept a custom ChainConfigEntry', () => {
-        const custom = {
-            ...CHAIN_CONFIGS.base,
-            chainId: 999,
-            name: 'CustomChain',
-        };
-
-        const kasu = Kasu.create({
-            chain: custom,
-            signerOrProvider: mockProvider as never,
-        });
-
-        expect(kasu.chainConfig.chainId).toBe(999);
-        expect(kasu.chainConfig.name).toBe('CustomChain');
-    });
-
-    it('should accept configOverrides', () => {
-        const kasu = Kasu.create({
-            chain: 'base',
-            signerOrProvider: mockProvider as never,
-            configOverrides: {
-                UNUSED_LENDING_POOL_IDS: ['0xdead'],
-            },
-        });
-
-        expect(kasu).toBeInstanceOf(Kasu);
-    });
-
-    it('constructs without a directusUrl — on-chain data does not need one', () => {
-        // `createDirectus('')` throws `Invalid URL`, so an SDK configured
-        // without the (documented-optional) CMS URL used to be
-        // unconstructable rather than merely CMS-less.
-        const kasu = Kasu.create({
-            chain: 'base',
-            signerOrProvider: mockProvider as never,
-            configOverrides: { directusUrl: '' },
-        });
-
-        expect(kasu).toBeInstanceOf(Kasu);
-        expect(kasu.services.DataService).toBeDefined();
-        expect(kasu.services.UserLending).toBeDefined();
-    });
-
-    it('refuses a CMS-only call clearly when no directusUrl is configured', async () => {
-        const kasu = Kasu.create({
-            chain: 'base',
-            signerOrProvider: mockProvider as never,
-            configOverrides: { directusUrl: '' },
-        });
-
-        // A sentence naming what to configure, not a null dereference thrown
-        // from inside the vendor SDK.
-        await expect(
-            kasu.services.DataService.getPlatformOverview(),
-        ).rejects.toThrow(NO_DIRECTUS_URL_MESSAGE);
-    });
-
-    it('should expose the underlying KasuSdk via .services', () => {
-        const kasu = Kasu.create({
-            chain: 'base',
-            signerOrProvider: mockProvider as never,
-        });
-
-        expect(kasu.services).toBeDefined();
-        expect(kasu.services.DataService).toBeDefined();
-        expect(kasu.services.UserLending).toBeDefined();
-        expect(kasu.services.Locking).toBeDefined();
-        expect(kasu.services.Portfolio).toBeDefined();
-    });
-});
-
-// ---------------------------------------------------------------------------
-// StrategiesFacade.calculateDepositLimits()
-// ---------------------------------------------------------------------------
-
-describe('StrategiesFacade.calculateDepositLimits()', () => {
-    // We can test this pure function without network calls by constructing
-    // a StrategiesFacade with null services and calling calculateDepositLimits directly.
-    const facade = new StrategiesFacade(null as never, null as never);
-
-    it('should enforce minimum of 1 USDC', () => {
-        const tranche = makeTranche({
-            minimumDeposit: '0.5',
-            maximumDeposit: '10000',
-            poolCapacity: '50000',
-        });
-
-        const limits = facade.calculateDepositLimits(tranche);
-        expect(limits.min).toBe('1');
-        expect(limits.max).toBe('10000');
-        expect(limits.availableCapacity).toBe('50000');
-    });
-
-    it('should pass through minimum when >= 1', () => {
-        const tranche = makeTranche({
-            minimumDeposit: '100',
-            maximumDeposit: '10000',
-            poolCapacity: '50000',
-        });
-
-        const limits = facade.calculateDepositLimits(tranche);
-        expect(limits.min).toBe('100');
-    });
-
-    it('should cap max at pool capacity when capacity is lower', () => {
-        const tranche = makeTranche({
-            minimumDeposit: '100',
-            maximumDeposit: '50000',
-            poolCapacity: '10000',
-        });
-
-        const limits = facade.calculateDepositLimits(tranche);
-        expect(limits.max).toBe('10000');
-    });
-
-    it('should use maximumDeposit when capacity is higher', () => {
-        const tranche = makeTranche({
-            minimumDeposit: '100',
-            maximumDeposit: '5000',
-            poolCapacity: '50000',
-        });
-
-        const limits = facade.calculateDepositLimits(tranche);
-        expect(limits.max).toBe('5000');
-    });
-});
-
-// ---------------------------------------------------------------------------
-// PortfolioFacade.getRequestStates()
-// ---------------------------------------------------------------------------
-
-describe('PortfolioFacade.getRequestStates()', () => {
-    it('maps the transaction history through deriveRequestState', async () => {
-        const requests: UserRequest[] = [
-            makeUserRequest({ id: 'req-1' }),
-            makeUserRequest({
-                id: 'req-2',
-                requestType: 'Withdrawal',
-                status: UserRequestStatus.PROCESSED,
-                canCancel: false,
-                acceptedAmount: '100',
-            }),
-        ];
-        const userLending = {
-            getCurrentEpoch: (): Promise<string> => Promise.resolve('42'),
-            getUserRequests: (): Promise<UserRequest[]> =>
-                Promise.resolve(requests),
-        } as unknown as UserLending;
-
-        const facade = new PortfolioFacade(
-            {} as unknown as DataService,
-            userLending,
-            {} as unknown as Portfolio,
-        );
-
-        const states = await facade.getRequestStates('0xuser');
-
-        expect(states.map((s) => s.id)).toEqual(['req-1', 'req-2']);
-        expect(states[0].statusCode).toBe('pending');
-        expect(states[0].amount).toBe(100);
-        expect(states[1].statusCode).toBe('complete');
-        expect(states[1].amount).toBe(-100);
-    });
-
-    it('returns an empty list for a wallet with no history', async () => {
-        const userLending = {
-            getCurrentEpoch: (): Promise<string> => Promise.resolve('42'),
-            getUserRequests: (): Promise<UserRequest[]> => Promise.resolve([]),
-        } as unknown as UserLending;
-
-        const facade = new PortfolioFacade(
-            {} as unknown as DataService,
-            userLending,
-            {} as unknown as Portfolio,
-        );
-
-        await expect(facade.getRequestStates('0xuser')).resolves.toEqual([]);
-    });
-});
-
-// ---------------------------------------------------------------------------
-// Type exports — verify key facade types are importable
-// ---------------------------------------------------------------------------
-
-describe('Type re-exports', () => {
-    it('should export facade classes from the main entry', () => {
-        // Verify the barrel exports resolve — these would fail at compile time
-        // if the re-exports were broken.
-        expect(Kasu).toBeDefined();
-        expect(CHAIN_CONFIGS).toBeDefined();
-        expect(StrategiesFacade).toBeDefined();
-        expect(DepositsFacade).toBeDefined();
-        expect(PortfolioFacade).toBeDefined();
-    });
-});
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-function makeTranche(raw: {
-    minimumDeposit: string;
-    maximumDeposit: string;
-    poolCapacity: string;
-}) {
-    return {
-        id: '0xtest',
-        name: 'Test Tranche',
-        apy: 0.08,
-        minApy: 0.06,
-        maxApy: 0.10,
-        minimumDeposit: raw.minimumDeposit,
-        maximumDeposit: raw.maximumDeposit,
-        availableCapacity: raw.poolCapacity,
-        fixedTermOptions: [],
-        _raw: {
-            ...raw,
-            id: '0xtest',
-            name: 'Test Tranche',
-            apy: '0.08',
-            minApy: '0.06',
-            maxApy: '0.10',
-            fixedTermConfig: [],
-        },
-    } as never;
-}
-
-
-function makeUserRequest(overrides: Partial<UserRequest> = {}): UserRequest {
-    return {
-        id: 'req-1',
-        userId: '0xuser',
-        lendingPool: { id: '0xpool', name: 'Pool', tranches: [{ orderId: '0' }] },
-        requestType: 'Deposit',
-        trancheId: '0xtranche',
-        trancheName: 'Senior',
-        requestedAmount: '100',
-        acceptedAmount: '0',
-        rejectedAmount: '0',
-        timestamp: 1_700_000_000,
-        status: UserRequestStatus.REQUESTED,
-        canCancel: true,
-        events: [],
-        nftId: '',
-        apy: '0',
-        fixedTermConfig: undefined,
-        ...overrides,
-    };
-}

package/src/services/Locking/calculate-apy.test.ts

@@ -1,52 +0,0 @@
-import { providers } from 'ethers';
-
-import { apyToEpochRate, epochRateToApy } from '../../domain/rates';
-import { CHAIN_CONFIGS } from '../../facade/chain-configs';
-import { SdkConfig } from '../../sdk-config';
-
-import { KSULocking } from './locking';
-
-// Offline: the constructor only builds contract instances. Nothing here calls
-// the RPC or the subgraph.
-function locking(): KSULocking {
-    const chain = CHAIN_CONFIGS.base;
-    const config = new SdkConfig({
-        subgraphUrl: 'https://example.invalid/subgraph',
-        contracts: chain.contracts,
-        UNUSED_LENDING_POOL_IDS: [''],
-    });
-    return new KSULocking(
-        config,
-        new providers.StaticJsonRpcProvider(chain.rpcUrls[0], chain.chainId),
-    );
-}
-
-describe('KSULocking.calculateApy', () => {
-    it('compounds the epoch rate instead of XOR-ing it', () => {
-        // The old body was `(1 + r) ^ (EPOCHS_IN_YEAR - 1)` — bitwise XOR on
-        // int32 operands, so every realistic rate returned the constant 50.
-        for (const r of [0.001, 0.0025, 0.003, 0.005]) {
-            expect(locking().calculateApy(r)).toBe(epochRateToApy(r));
-            expect(locking().calculateApy(r)).not.toBe(50);
-        }
-    });
-
-    it('lands on the APYs the platform actually quotes', () => {
-        // Every live tranche APY, back through its own per-epoch rate.
-        for (const apy of [0.1, 0.12, 0.14, 0.16, 0.22, 0.3]) {
-            expect(locking().calculateApy(apyToEpochRate(apy))).toBeCloseTo(
-                apy,
-                10,
-            );
-        }
-        expect(locking().calculateApy(0)).toBe(0);
-    });
-
-    it('agrees with DataService.calculateApyForTranche', () => {
-        // The two used to carry separate copies of the constant AND separate
-        // (one of them wrong) formulas.
-        for (const r of [0.001, 0.003, 0.01]) {
-            expect(locking().calculateApy(r)).toBe(epochRateToApy(r));
-        }
-    });
-});