@kasufinance/kasu-sdk 2.5.0 → 2.7.0

package/src/facade/facade.test.ts

@@ -1,250 +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 { 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('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('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');
-    });
-});
-
-// ---------------------------------------------------------------------------
-// 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;
-}

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

package/src/tests/sample.test.ts

@@ -1,63 +0,0 @@
-/**
- * Live-network spec. It talks to a real subgraph and a real RPC, so it is
- * OPT-IN: it runs only under `LIVE_TESTS=1` (`npm run test:live`) and is
- * skipped by `npm test` and `npm run test:unit`. A network problem must never
- * be able to fail a pull request that did not touch the network.
- *
- * Known state: the stack it points at (`kasu-wip-sepolia` on The Graph Studio,
- * with Base Sepolia addresses) is decommissioned, so `npm run test:live` fails
- * on a missing deployment. That is pre-existing and unrelated to the gate; the
- * spec needs retargeting at a live deployment before it means anything.
- */
-import * as ethers from 'ethers';
-
-import { KasuSdk } from '..';
-import { SdkConfig } from '../sdk-config';
-
-const live = process.env.LIVE_TESTS === '1';
-
-(live ? describe : describe.skip)('live network — subgraph read', () => {
-    it('reads a user APY bonus through the subgraph', async () => {
-        const provider = new ethers.providers.JsonRpcProvider(
-            'https://sepolia.base.org',
-        );
-
-        // Generated per run. This spec only reads, so the wallet never needs
-        // funds or a key that outlives the process — and a public repository
-        // must never carry one.
-        const wallet = ethers.Wallet.createRandom().connect(provider);
-
-        const config = new SdkConfig({
-            subgraphUrl:
-                'https://api.studio.thegraph.com/query/63245/kasu-wip-sepolia/version/latest',
-            contracts: {
-                IKSULocking: '0x529A81c11ab6176c5E88670d293BB771800066a2',
-                IKSULockBonus: '0xBBfFd5F744156FFc526df12F5e09dC7b208Be740',
-                // The allow below is for a public Base Sepolia contract
-                // address, not a secret: the generic-api-key rule fires on a
-                // "Token" key name sitting next to a long hex literal.
-                KSUToken: '0xa0f698Feb9Bc2BeA6E85eb071D5E3F59dc5bC56b', // gitleaks:allow
-                UserManager: '0xA788e9223fDd7c9Db91Ef133BbeB73515c174773',
-                LendingPoolManager: '0xc074Aaf2565aae18db2c7498ee1387610a809F40',
-                KasuAllowList: '0xaE94F9D187c9eA649ADd4966340831F7cc62B69c',
-                SystemVariables: '0xB174a3240B23e595e90bC2736A5b8ec674Cba73A',
-                UserLoyaltyRewards:
-                    '0x259631CE76FD9F65296549Cd81232aa59D53Dd0c',
-                KsuPrice: '0x2027192aCFB4810Ad734A212F19d7030F698aCE3',
-                ClearingCoordinator:
-                    '0x2027192aCFB4810Ad734A212F19d7030F698aCE3',
-                KasuNFTs: '0x0000000000000000000000000000000000000000',
-                ExternalTVL: '0x0000000000000000000000000000000000000000',
-            },
-            directusUrl: 'https://kasu-finance.directus.app',
-            UNUSED_LENDING_POOL_IDS: [''],
-        });
-        const sdk = new KasuSdk(config, wallet);
-
-        const bonus = await sdk.UserLending.getUserApyBonus(
-            '0xef38c432682ab49095e00442aaa354e955ac03a5',
-        );
-
-        expect(bonus).toBeDefined();
-    });
-});