@kasufinance/kasu-sdk 2.4.2 → 2.5.0

package/src/domain/tranches.ts

@@ -0,0 +1,177 @@
+import { PoolOverview, TrancheData } from '../services/DataService/types';
+
+import { netEffectiveApy } from './rates';
+
+/**
+ * Minimum remaining capacity (in stable-asset units) for a tranche to be
+ * selectable. Mirrors `MIN_CAPACITY = toBigNumber('1')` in kasu-fe-next's
+ * lending modal after its `formatEther`. Anything below this is rounding
+ * noise — the SDK's own capacity arithmetic routinely leaves sub-cent dust
+ * behind.
+ */
+export const MIN_TRANCHE_CAPACITY = 1;
+
+/**
+ * Remaining capacity as it reaches this layer. `TrancheData` (raw, from the
+ * data service) calls it `poolCapacity`; the facade's `StrategyTranche` calls
+ * the same number `availableCapacity`. Accepting both keeps ONE capacity gate
+ * for the whole SDK rather than a duplicate per shape.
+ */
+export type TrancheCapacitySignal =
+    | { poolCapacity: string }
+    | { availableCapacity: string };
+
+export function trancheHasCapacity(tranche: TrancheCapacitySignal): boolean {
+    const raw =
+        'poolCapacity' in tranche
+            ? tranche.poolCapacity
+            : tranche.availableCapacity;
+    const remaining = parseFloat(raw);
+    return Number.isFinite(remaining) && remaining >= MIN_TRANCHE_CAPACITY;
+}
+
+/**
+ * Whole-strategy capacity gate: true when the pool has tranches but none of
+ * them has remaining capacity. Drives a lend form's full-capacity message and
+ * its step-counter suppression.
+ */
+export function poolAllTranchesFull(pool: PoolOverview): boolean {
+    return pool.tranches.length > 0 && !pool.tranches.some(trancheHasCapacity);
+}
+
+export type PoolStatus = 'Live' | 'Full' | 'Coming soon';
+
+/**
+ * The status CODE for a pool. A code, not copy: consumers map it to their own
+ * wording and locale.
+ */
+export function derivePoolStatus(pool: PoolOverview): PoolStatus {
+    if (!pool.enabled) return 'Coming soon';
+    if (poolAllTranchesFull(pool)) return 'Full';
+    return 'Live';
+}
+
+/**
+ * Seniority rank of a tranche by name — LOWER is less risky. The credit
+ * waterfall is Senior (repaid first, lowest risk) → Mezzanine → Junior
+ * (repaid last, highest risk). APY is NOT a reliable proxy (a pool can price
+ * its Senior tranche above its Mezzanine), so risk is ranked by name.
+ * Unrecognised names sort last, so a known-safe tranche always wins the
+ * default. Ranks by the RAW subgraph name — the Apxium "Upper Mezzanine"
+ * rename is display-only and must never reach here (see
+ * `tranche-display-name.ts`).
+ */
+const TRANCHE_RISK_RANK: Record<string, number | undefined> = {
+    senior: 0,
+    mezzanine: 1,
+    junior: 2,
+};
+
+// `name` is typed `string` on `TrancheData` but arrives from the subgraph, so
+// it is taken as possibly missing here: an unnamed tranche ranks last rather
+// than throwing on `.trim()`.
+function riskRankOfName(name: string | undefined): number {
+    return (
+        TRANCHE_RISK_RANK[name?.trim().toLowerCase() ?? ''] ??
+        Number.POSITIVE_INFINITY
+    );
+}
+
+export function trancheRiskRank(tranche: TrancheData): number {
+    return riskRankOfName(tranche.name);
+}
+
+/**
+ * Comparator that orders tranches SAFEST-FIRST (Senior → Mezzanine → Junior)
+ * by the same name-based risk rank the default-pick uses. Ranks by the RAW
+ * subgraph name, so the Apxium "Upper Mezzanine" display rename never reaches
+ * here. Ties (incl. unrecognised names, which both rank last) keep their input
+ * order under a stable sort. Used by a lend dropdown to list the least-risky
+ * option first.
+ */
+export function compareTrancheSeniority(a: TrancheData, b: TrancheData): number {
+    const ra = trancheRiskRank(a);
+    const rb = trancheRiskRank(b);
+    if (ra === rb) return 0;
+    return ra < rb ? -1 : 1;
+}
+
+/**
+ * Capacity-aware default tranche pick: the LOWEST-risk tranche that still has
+ * capacity, so a new lender lands on the safest available option. Riskier
+ * tranches remain a deliberate opt-in — we must never pre-select the
+ * highest-risk Junior (audit 3.2). When every tranche is full we fall back to
+ * the lowest-risk one regardless, so a form still mounts in a known state
+ * (the dropdown marks it full and the submit gate blocks progress).
+ */
+export function pickDefaultTrancheId(pool: PoolOverview): string {
+    const withCapacity = pool.tranches.filter(trancheHasCapacity);
+    const candidates = withCapacity.length > 0 ? withCapacity : pool.tranches;
+    if (candidates.length === 0) return '';
+    return candidates.reduce((best, t) =>
+        trancheRiskRank(t) < trancheRiskRank(best) ? t : best,
+    ).id;
+}
+
+/** A closed APY range, both bounds as 0..1 fractions. */
+export interface ApyBounds {
+    min: number;
+    max: number;
+}
+
+/**
+ * GROSS APY range across a pool's tranches — the numeric core of kasu-ui's
+ * `formatTrancheApyRange`. Each `TrancheData` carries `minApy`/`maxApy`
+ * derived from the base rate plus any fixed-term configs (`data-service.ts`).
+ *
+ * Zero and negative values are skipped — an unset/missing rate (e.g. a tranche
+ * with no fixed-term config) must not drag the range down to `0–10.5%`.
+ * `null` when nothing usable remains, which is the caller's cue to render its
+ * "no rate" state rather than a confident zero.
+ *
+ * The min is taken over `minApy` and the max over `maxApy`, so a single
+ * unusable side collapses the whole range to `null` rather than half a range.
+ *
+ * Formatting is NOT here. The rule that two bounds printing the same figure
+ * collapse to one is decided on the rendered digits, so it belongs with the
+ * formatter that produces them (kasu-ui `format-tranche-apy.ts`).
+ */
+export function trancheApyBounds(tranches: TrancheData[]): ApyBounds | null {
+    if (tranches.length === 0) return null;
+    let lo = Number.POSITIVE_INFINITY;
+    let hi = Number.NEGATIVE_INFINITY;
+    for (const t of tranches) {
+        const min = parseFloat(t.minApy);
+        const max = parseFloat(t.maxApy);
+        if (Number.isFinite(min) && min > 0) lo = Math.min(lo, min);
+        if (Number.isFinite(max) && max > 0) hi = Math.max(hi, max);
+    }
+    if (!Number.isFinite(lo) || !Number.isFinite(hi)) return null;
+    return { min: lo, max: hi };
+}
+
+/**
+ * The same range as NET Effective Interest Rates — each bound through
+ * `netEffectiveApy`.
+ *
+ * FAIL CLOSED: `null` when either bound comes back non-finite or ≤ 0, so an
+ * out-of-domain fee or a rate-less pool can never be rendered as a confident
+ * figure. A caller that does not yet know the fee must not substitute `0` —
+ * a fee-less rate overstates the figure by up to 3.4pp with nothing on screen
+ * saying so; it should skip the call and render its unavailable state.
+ *
+ * @param feePercent the chain's performance fee, 0..100 — never a fraction.
+ *   See `netEffectiveApy` for why the units matter.
+ */
+export function netTrancheApyBounds(
+    tranches: TrancheData[],
+    feePercent: number,
+): ApyBounds | null {
+    const gross = trancheApyBounds(tranches);
+    if (!gross) return null;
+    const min = netEffectiveApy(gross.min, feePercent);
+    const max = netEffectiveApy(gross.max, feePercent);
+    if (!Number.isFinite(min) || min <= 0) return null;
+    if (!Number.isFinite(max) || max <= 0) return null;
+    return { min, max };
+}

package/src/facade/chain-configs.ts

@@ -1,5 +1,20 @@
 import { ChainConfigEntry } from './types';
 
+/**
+ * Browser-viable XDC RPCs only. `rpc.xdc.org` / `erpc.xdc.org` answer OPTIONS
+ * without `access-control-allow-origin`, so a browser call hangs on preflight
+ * — they must never appear here. The four below ship CORS `*` and are DISTINCT
+ * operators, so one vendor incident cannot exhaust the list. Order is a
+ * STARTING preference only; consumers are expected to fold the list into their
+ * own failover. Shared by both XDC deployments (same chain, same endpoints).
+ */
+const XDC_RPC_URLS: string[] = [
+    'https://rpc.ankr.com/xdc',
+    'https://rpc.xdcrpc.com',
+    'https://rpc.xinfin.network',
+    'https://rpc.primenumbers.xyz/',
+];
+
 /**
  * Built-in chain configurations for Kasu-supported networks.
  *
@@ -33,6 +48,17 @@ export const CHAIN_CONFIGS: Record<'base' | 'xdc' | 'xdc-usdc' | 'plume', ChainC
         directusUrl: 'https://kasu-finance.directus.app/',
         unusedPoolIds: [],
         poolMetadataMapping: undefined,
+        stableAsset: {
+            address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+            symbol: 'USDC',
+            name: 'USD Coin',
+            decimals: 6,
+            currencyCode: 'USD',
+        },
+        rpcUrls: [
+            'https://base-rpc.publicnode.com',
+            'https://mainnet.base.org',
+        ],
     },
 
     xdc: {
@@ -65,6 +91,14 @@ export const CHAIN_CONFIGS: Record<'base' | 'xdc' | 'xdc-usdc' | 'plume', ChainC
             '0xeda50c91a8c4ca8a83652b8542c0b3bd00a71fad':
                 '0xc347a9e4aec8c8d11a149d2907deb2bf23b81c6f',
         },
+        stableAsset: {
+            address: '0x9fe4e6321eeb7c4bc537570f015e4734b15002b8',
+            symbol: 'AUDD',
+            name: 'Novatti Australian Dollar',
+            decimals: 6,
+            currencyCode: 'AUD',
+        },
+        rpcUrls: XDC_RPC_URLS,
     },
 
     'xdc-usdc': {
@@ -90,6 +124,14 @@ export const CHAIN_CONFIGS: Record<'base' | 'xdc' | 'xdc-usdc' | 'plume', ChainC
         directusUrl: 'https://kasu-finance.directus.app/',
         unusedPoolIds: [],
         poolMetadataMapping: undefined,
+        stableAsset: {
+            address: '0xfa2958cb79b0491cc627c1557f441ef849ca8eb1',
+            symbol: 'USDC',
+            name: 'USD Coin',
+            decimals: 6,
+            currencyCode: 'USD',
+        },
+        rpcUrls: XDC_RPC_URLS,
     },
 
     plume: {
@@ -114,5 +156,18 @@ export const CHAIN_CONFIGS: Record<'base' | 'xdc' | 'xdc-usdc' | 'plume', ChainC
         directusUrl: 'https://kasu-finance.directus.app/',
         unusedPoolIds: [],
         poolMetadataMapping: undefined,
+        stableAsset: {
+            address: '0xdddD73F5Df1F0DC31373357beAC77545dC5A6f3F',
+            symbol: 'pUSD',
+            name: 'Plume USD',
+            decimals: 6,
+            currencyCode: 'USD',
+        },
+        // Retired — drained and wound down. No default RPC, so a read-only
+        // `Kasu.create({ chain: 'plume' })` throws rather than quietly
+        // pointing at an endpoint nobody maintains. Pass your own
+        // `signerOrProvider` to read the frozen history.
+        rpcUrls: [],
+        retired: true,
     },
 };

package/src/facade/config.test.ts

@@ -0,0 +1,265 @@
+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/deposits.ts

@@ -14,8 +14,30 @@ export class DepositsFacade {
     constructor(
         private _userLending: UserLending,
         private _chainId: string,
+        /**
+         * True when the SDK holds a Provider rather than a Signer. Optional and
+         * defaulting to false so constructing this facade directly keeps
+         * working; `Kasu` always passes it.
+         */
+        private _isReadOnly = false,
     ) {}
 
+    /**
+     * Refuse a write BEFORE touching the contract.
+     *
+     * ethers would throw its own "sending a transaction requires a signer" a
+     * few frames deeper, after the params have been encoded — a message that
+     * says nothing about how to get a signer onto THIS object. Failing here
+     * names the fix.
+     */
+    private assertWritable(): void {
+        if (this._isReadOnly) {
+            throw new Error(
+                'Kasu: this instance is read-only; call kasu.connect(signer) first',
+            );
+        }
+    }
+
     /**
      * Submit a deposit request.
      *
@@ -34,6 +56,7 @@ export class DepositsFacade {
      * ```
      */
     async deposit(params: DepositParams): Promise<ContractTransaction> {
+        this.assertWritable();
         return await this._userLending.requestDepositWithKyc(
             params.poolId,
             params.trancheId,
@@ -50,6 +73,7 @@ export class DepositsFacade {
      * Submit a withdrawal request for a specific stable asset amount.
      */
     async withdraw(params: WithdrawParams): Promise<ContractTransaction> {
+        this.assertWritable();
         return await this._userLending.requestWithdrawalInAsset(
             params.poolId,
             params.trancheId,
@@ -65,6 +89,7 @@ export class DepositsFacade {
         trancheId: string,
         userAddress: string,
     ): Promise<ContractTransaction> {
+        this.assertWritable();
         return await this._userLending.requestWithdrawalMax(
             poolId,
             trancheId,

package/src/{tests → facade}/facade.test.ts

@@ -1,8 +1,13 @@
-import { CHAIN_CONFIGS } from '../facade/chain-configs';
-import { DepositsFacade } from '../facade/deposits';
-import { Kasu } from '../facade/kasu';
-import { StrategiesFacade } from '../facade/strategies';
-import { PortfolioFacade } from '../facade/user-portfolio';
+/**
+ * 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

package/src/facade/index.ts

@@ -9,10 +9,14 @@ export { PortfolioFacade } from './user-portfolio';
 // Chain configurations
 export { CHAIN_CONFIGS } from './chain-configs';
 
+// Directus-backed helpers (I/O — not part of `domain/`)
+export { fetchUnusedPoolIds } from './unused-pool-ids';
+
 // All facade types
 export type {
     SupportedChain,
     ChainConfigEntry,
+    StableAsset,
     KasuOptions,
     Strategy,
     StrategyTranche,