@kasufinance/kasu-sdk 2.6.0 → 2.7.0

package/src/domain/settlement.test.ts

@@ -1,198 +0,0 @@
-import {
-    CLEARING_WINDOW_SECONDS,
-    computeSettlementWindow,
-    deriveCycleDates,
-    nextCycleBoundary,
-} from './settlement';
-
-/**
- * Ported from kasu-ui `src/features/portfolio/lib/settlement-window.test.ts`
- * and the non-format half of
- * `src/features/lending/lib/cycle-dates.test.ts`. The `formatCycleDate` /
- * `formatCycleCloseUtc` cases stay there — they assert printed words.
- */
-
-const HOUR = 60 * 60;
-const DAY = 24 * HOUR;
-const CLEARING = 48 * HOUR;
-const WEEK = 7 * DAY;
-
-describe('computeSettlementWindow', () => {
-    it('returns "unknown" when the epoch boundary is missing', () => {
-        expect(
-            computeSettlementWindow({
-                nowSeconds: 1_000_000,
-                nextEpochStart: 0,
-            }),
-        ).toEqual({ phase: 'unknown' });
-    });
-
-    it('returns "unknown" when the epoch boundary is stale (already elapsed)', () => {
-        expect(
-            computeSettlementWindow({
-                nowSeconds: 1_000_000,
-                nextEpochStart: 999_000,
-            }),
-        ).toEqual({ phase: 'unknown' });
-    });
-
-    it('counts down to the clearing window when more than 48h from epoch end', () => {
-        const epochEnd = 1_700_000_000; // Thu 06:00 UTC
-        const now = epochEnd - 3 * DAY; // 24h before the window opens
-        const result = computeSettlementWindow({
-            nowSeconds: now,
-            nextEpochStart: epochEnd,
-        });
-
-        expect(result.phase).toBe('awaiting');
-        if (result.phase !== 'awaiting') return;
-        expect(result.nextClearingStart).toBe(epochEnd - CLEARING); // Tue 06:00
-        expect(result.secondsUntilClearing).toBe(DAY);
-    });
-
-    it('reports "clearing" only inside the 48h window before epoch end', () => {
-        const epochEnd = 1_700_000_000;
-        const now = epochEnd - 24 * HOUR; // 24h into the window
-        const result = computeSettlementWindow({
-            nowSeconds: now,
-            nextEpochStart: epochEnd,
-        });
-
-        expect(result.phase).toBe('clearing');
-        if (result.phase !== 'clearing') return;
-        expect(result.epochEnd).toBe(epochEnd);
-        expect(result.secondsUntilEpochEnd).toBe(24 * HOUR);
-    });
-
-    it('flips awaiting → clearing exactly at the window boundary (T-48h)', () => {
-        const epochEnd = 1_700_000_000;
-        expect(
-            computeSettlementWindow({
-                nowSeconds: epochEnd - CLEARING - 1,
-                nextEpochStart: epochEnd,
-            }).phase,
-        ).toBe('awaiting');
-        expect(
-            computeSettlementWindow({
-                nowSeconds: epochEnd - CLEARING,
-                nextEpochStart: epochEnd,
-            }).phase,
-        ).toBe('clearing');
-    });
-
-    it('respects a non-default clearing window length', () => {
-        const epochEnd = 1_700_000_000;
-        const now = epochEnd - 36 * HOUR;
-        // 36h out is "clearing" under the default 48h window but "awaiting"
-        // under a 24h one.
-        expect(
-            computeSettlementWindow({
-                nowSeconds: now,
-                nextEpochStart: epochEnd,
-            }).phase,
-        ).toBe('clearing');
-        expect(
-            computeSettlementWindow({
-                nowSeconds: now,
-                nextEpochStart: epochEnd,
-                clearingWindowSeconds: 24 * HOUR,
-            }).phase,
-        ).toBe('awaiting');
-    });
-});
-
-describe('nextCycleBoundary', () => {
-    const epochEnd = 1_700_000_000;
-    const clearingStart = epochEnd - CLEARING;
-
-    it('returns the cycle close while the window is still ahead', () => {
-        expect(nextCycleBoundary(epochEnd, epochEnd - 3 * DAY)).toBe(
-            clearingStart,
-        );
-    });
-
-    it('returns the epoch end once inside the clearing window', () => {
-        expect(nextCycleBoundary(epochEnd, clearingStart + 1)).toBe(epochEnd);
-    });
-
-    it('hands over from close to epoch end exactly at the boundary instant', () => {
-        // At T-48h the close has just been reached, so the next thing to wait
-        // for is the epoch end — not the instant we are standing on.
-        expect(nextCycleBoundary(epochEnd, clearingStart - 1)).toBe(
-            clearingStart,
-        );
-        expect(nextCycleBoundary(epochEnd, clearingStart)).toBe(epochEnd);
-    });
-
-    it('returns undefined when there is nothing left to wait for', () => {
-        expect(nextCycleBoundary(epochEnd, epochEnd)).toBeUndefined(); // elapsed
-        expect(nextCycleBoundary(epochEnd, epochEnd + DAY)).toBeUndefined(); // stale
-        expect(nextCycleBoundary(undefined, epochEnd - DAY)).toBeUndefined(); // not loaded
-        expect(nextCycleBoundary(0, epochEnd - DAY)).toBeUndefined(); // sentinel zero
-    });
-
-    it('agrees with computeSettlementWindow about where the window opens', () => {
-        // One number, two consumers: the phase machine and the timer helper
-        // must never disagree about when the cycle turns.
-        expect(CLEARING_WINDOW_SECONDS).toBe(CLEARING);
-        const justInside = nextCycleBoundary(epochEnd, clearingStart);
-        expect(
-            computeSettlementWindow({
-                nowSeconds: clearingStart,
-                nextEpochStart: epochEnd,
-            }).phase,
-        ).toBe('clearing');
-        expect(justInside).toBe(epochEnd);
-    });
-
-    it('respects a non-default clearing window length', () => {
-        const now = epochEnd - 36 * HOUR;
-        // 36h out: inside a 48h window (next stop is the epoch end), still
-        // ahead of a 24h one (next stop is that window opening).
-        expect(nextCycleBoundary(epochEnd, now)).toBe(epochEnd);
-        expect(nextCycleBoundary(epochEnd, now, 24 * HOUR)).toBe(
-            epochEnd - 24 * HOUR,
-        );
-    });
-});
-
-describe('deriveCycleDates', () => {
-    // Fixture: epoch end = Thu 6 Aug 2026, 06:00 UTC.
-    const EPOCH_END = Date.UTC(2026, 7, 6, 6, 0, 0) / 1000; // 1785996000
-    const CLOSE = EPOCH_END - CLEARING; // Tue 4 Aug 06:00 UTC
-
-    it('returns close = epochEnd − 48h and outcome = epochEnd before the window opens', () => {
-        const now = Date.UTC(2026, 7, 1, 12, 0, 0) / 1000; // Sat 1 Aug
-        expect(deriveCycleDates(EPOCH_END, now)).toEqual({
-            close: CLOSE,
-            outcome: EPOCH_END,
-        });
-    });
-
-    it('advances to the next weekly cycle when the request lands inside the clearing window', () => {
-        // now is Wed 5 Aug 00:00 — inside [close, epochEnd): this cycle has
-        // already closed, so the request queues for next week.
-        const now = Date.UTC(2026, 7, 5, 0, 0, 0) / 1000;
-        expect(deriveCycleDates(EPOCH_END, now)).toEqual({
-            close: CLOSE + WEEK,
-            outcome: EPOCH_END + WEEK,
-        });
-    });
-
-    it('returns null when the epoch boundary is missing', () => {
-        expect(deriveCycleDates(undefined, EPOCH_END - WEEK)).toBeNull();
-        expect(deriveCycleDates(0, EPOCH_END - WEEK)).toBeNull();
-    });
-
-    it('returns null when the epoch boundary is stale (already elapsed)', () => {
-        expect(deriveCycleDates(EPOCH_END, EPOCH_END + 60)).toBeNull();
-    });
-
-    it('runs on the same window constant as the phase machine', () => {
-        const now = Date.UTC(2026, 7, 1, 12, 0, 0) / 1000;
-        const dates = deriveCycleDates(EPOCH_END, now);
-        expect(dates?.outcome).toBe(
-            (dates?.close ?? 0) + CLEARING_WINDOW_SECONDS,
-        );
-    });
-});

package/src/domain/tranche-display-name.test.ts

@@ -1,96 +0,0 @@
-import { getTrancheDisplayName, UPPER_MEZZANINE } from './tranche-display-name';
-
-// Ported from kasu-ui `src/features/lending/lib/tranche-display-name.test.ts`.
-
-describe('getTrancheDisplayName', () => {
-    it('renames Senior to Upper Mezzanine on Apxium pools', () => {
-        expect(
-            getTrancheDisplayName('Senior', {
-                poolName: 'Taxation Funding (Tax Pay)',
-            }),
-        ).toBe(UPPER_MEZZANINE);
-        expect(
-            getTrancheDisplayName('Senior', {
-                poolName: 'Professional Fee Funding',
-            }),
-        ).toBe(UPPER_MEZZANINE);
-        expect(
-            getTrancheDisplayName('Senior', { poolName: 'Whole Ledger Funding' }),
-        ).toBe(UPPER_MEZZANINE);
-    });
-
-    it('keeps Senior on non-Apxium (InvoiceMate) pools', () => {
-        expect(
-            getTrancheDisplayName('Senior', {
-                poolName: 'Payment Finance (PayFi) - Clearing Houses',
-            }),
-        ).toBe('Senior');
-    });
-
-    it('never touches other tranche names, on any pool', () => {
-        expect(
-            getTrancheDisplayName('Mezzanine', { poolName: 'Taxation Funding' }),
-        ).toBe('Mezzanine');
-        expect(
-            getTrancheDisplayName('Junior', { poolName: 'Taxation Funding' }),
-        ).toBe('Junior');
-        expect(
-            getTrancheDisplayName('Mezzanine', {
-                poolName: 'Payment Finance (PayFi)',
-            }),
-        ).toBe('Mezzanine');
-    });
-
-    it('matches the Senior name case-insensitively but preserves unknown names verbatim', () => {
-        expect(
-            getTrancheDisplayName('SENIOR', { poolName: 'Taxation Funding' }),
-        ).toBe(UPPER_MEZZANINE);
-        expect(
-            getTrancheDisplayName('Senior Plus', { poolName: 'Taxation Funding' }),
-        ).toBe('Senior Plus');
-    });
-
-    it('treats missing pool names as Apxium (matches getCreditOriginator default)', () => {
-        // getCreditOriginator defaults unknown pools to Apxium; the display
-        // name must follow the same rule or the two surfaces would disagree.
-        expect(getTrancheDisplayName('Senior', { poolName: '' })).toBe(
-            UPPER_MEZZANINE,
-        );
-        expect(getTrancheDisplayName('Senior', {})).toBe(UPPER_MEZZANINE);
-    });
-});
-
-describe('getTrancheDisplayName — the widened PoolNameSignal', () => {
-    it('accepts the facade Strategy shape (`name`)', () => {
-        expect(getTrancheDisplayName('Senior', { name: 'Taxation Funding' })).toBe(
-            UPPER_MEZZANINE,
-        );
-        expect(
-            getTrancheDisplayName('Senior', {
-                name: 'Payment Finance (PayFi)',
-            }),
-        ).toBe('Senior');
-    });
-
-    it('accepts a bare pool name', () => {
-        expect(getTrancheDisplayName('Senior', 'Whole Ledger Funding')).toBe(
-            UPPER_MEZZANINE,
-        );
-        expect(getTrancheDisplayName('Senior', 'Payment Finance (PayFi)')).toBe(
-            'Senior',
-        );
-    });
-
-    it('gives the same answer for the raw and facade shapes of one pool', () => {
-        for (const poolName of [
-            'Taxation Funding (Tax Pay)',
-            'Payment Finance (PayFi)',
-            'Whole Ledger Funding',
-            '',
-        ]) {
-            expect(getTrancheDisplayName('Senior', { poolName })).toBe(
-                getTrancheDisplayName('Senior', { name: poolName }),
-            );
-        }
-    });
-});

package/src/domain/tranches.test.ts

@@ -1,300 +0,0 @@
-import * as fc from 'fast-check';
-
-import { PoolOverview, TrancheData } from '../services/DataService/types';
-
-import { netEffectiveApy } from './rates';
-import {
-    compareTrancheSeniority,
-    derivePoolStatus,
-    MIN_TRANCHE_CAPACITY,
-    netTrancheApyBounds,
-    pickDefaultTrancheId,
-    poolAllTranchesFull,
-    trancheApyBounds,
-    trancheHasCapacity,
-    trancheRiskRank,
-} from './tranches';
-
-/**
- * Ported from kasu-ui `pick-default-tranche.test.ts` and the NUMERIC half of
- * `format-tranche-apy.range.test.ts`. The formatting cases — whole-percent
- * rendering, the en-dash shape, the locale table and the "collapse when both
- * bounds print the same" rule — stay in kasu-ui: they are decided on rendered
- * digits, which this layer never produces.
- */
-
-// `id === name` keeps assertions readable; `poolCapacity` drives
-// `trancheHasCapacity` (≥ 1 stable unit → selectable).
-function tranche(name: string, poolCapacity: string, apy = '0.12'): TrancheData {
-    return { id: name, name, apy, poolCapacity } as unknown as TrancheData;
-}
-function pool(tranches: TrancheData[], enabled = true): PoolOverview {
-    return { id: 'p', poolName: 'p', enabled, tranches } as unknown as PoolOverview;
-}
-function rated(minApy: string, maxApy: string): TrancheData {
-    return { minApy, maxApy } as unknown as TrancheData;
-}
-
-/** The live performance fee on all deployments (subgraph units: 10 = 10%). */
-const FEE = 10;
-
-describe('trancheHasCapacity', () => {
-    it('accepts a tranche with at least one whole stable unit left', () => {
-        expect(trancheHasCapacity({ poolCapacity: '5000' })).toBe(true);
-        expect(
-            trancheHasCapacity({ poolCapacity: String(MIN_TRANCHE_CAPACITY) }),
-        ).toBe(true);
-    });
-
-    it('rejects sub-unit dust, zero and unparseable capacity', () => {
-        expect(trancheHasCapacity({ poolCapacity: '0.99' })).toBe(false);
-        expect(trancheHasCapacity({ poolCapacity: '0' })).toBe(false);
-        expect(
-            trancheHasCapacity({ poolCapacity: '1.4551915228366852e-11' }),
-        ).toBe(false);
-        expect(trancheHasCapacity({ poolCapacity: '' })).toBe(false);
-        expect(trancheHasCapacity({ poolCapacity: 'not-a-number' })).toBe(false);
-    });
-
-    it('reads the facade tranche shape (availableCapacity) identically', () => {
-        // `StrategyTranche` renames the same number; one gate, both shapes.
-        expect(trancheHasCapacity({ availableCapacity: '5000' })).toBe(true);
-        expect(trancheHasCapacity({ availableCapacity: '0' })).toBe(false);
-    });
-});
-
-describe('trancheRiskRank / compareTrancheSeniority', () => {
-    it('ranks the waterfall safest-first by the RAW name', () => {
-        expect(trancheRiskRank(tranche('Senior', '1'))).toBe(0);
-        expect(trancheRiskRank(tranche('Mezzanine', '1'))).toBe(1);
-        expect(trancheRiskRank(tranche('Junior', '1'))).toBe(2);
-    });
-
-    it('is case- and whitespace-insensitive, and sorts unknown names last', () => {
-        expect(trancheRiskRank(tranche('  SENIOR ', '1'))).toBe(0);
-        expect(trancheRiskRank(tranche('Upper Mezzanine', '1'))).toBe(
-            Number.POSITIVE_INFINITY,
-        );
-    });
-
-    it('sorts Senior → Mezzanine → Junior, keeping ties in input order', () => {
-        const tranches = [
-            tranche('Junior', '5000'),
-            tranche('Tranche B', '5000'),
-            tranche('Senior', '5000'),
-            tranche('Tranche A', '5000'),
-            tranche('Mezzanine', '5000'),
-        ];
-        expect(
-            [...tranches].sort(compareTrancheSeniority).map((t) => t.name),
-        ).toEqual([
-            'Senior',
-            'Mezzanine',
-            'Junior',
-            'Tranche B',
-            'Tranche A',
-        ]);
-    });
-});
-
-describe('pickDefaultTrancheId', () => {
-    it('defaults to the lowest-risk tranche (Senior) when all have capacity', () => {
-        // Subgraph order is Junior → Mezzanine → Senior; the default must NOT
-        // be the highest-risk Junior that sits first (audit 3.2).
-        const id = pickDefaultTrancheId(
-            pool([
-                tranche('Junior', '5000'),
-                tranche('Mezzanine', '5000'),
-                tranche('Senior', '5000'),
-            ]),
-        );
-        expect(id).toBe('Senior');
-    });
-
-    it('picks the lowest-risk tranche that is still AVAILABLE (skips a full Senior)', () => {
-        const id = pickDefaultTrancheId(
-            pool([
-                tranche('Junior', '5000'),
-                tranche('Mezzanine', '5000'),
-                tranche('Senior', '0'),
-            ]),
-        );
-        expect(id).toBe('Mezzanine');
-    });
-
-    it('does not rank by APY — a Senior priced above Mezzanine is still preferred', () => {
-        // Real pools can price Senior above Mezzanine; risk is ranked by name,
-        // not rate.
-        const id = pickDefaultTrancheId(
-            pool([
-                tranche('Mezzanine', '5000', '0.15'),
-                tranche('Senior', '5000', '0.18'),
-            ]),
-        );
-        expect(id).toBe('Senior');
-    });
-
-    it('falls back to the lowest-risk tranche when every tranche is full', () => {
-        const id = pickDefaultTrancheId(
-            pool([tranche('Junior', '0'), tranche('Senior', '0')]),
-        );
-        expect(id).toBe('Senior');
-    });
-
-    it('falls back to the first available tranche when names are unrecognised', () => {
-        const id = pickDefaultTrancheId(
-            pool([tranche('Tranche B', '5000'), tranche('Tranche A', '5000')]),
-        );
-        expect(id).toBe('Tranche B');
-    });
-
-    it('returns an empty string for a pool with no tranches', () => {
-        expect(pickDefaultTrancheId(pool([]))).toBe('');
-    });
-});
-
-describe('poolAllTranchesFull', () => {
-    it('is true when every tranche lacks remaining capacity', () => {
-        expect(
-            poolAllTranchesFull(
-                pool([tranche('Junior', '0'), tranche('Senior', '0')]),
-            ),
-        ).toBe(true);
-    });
-
-    it('is false when at least one tranche still has capacity', () => {
-        expect(
-            poolAllTranchesFull(
-                pool([tranche('Junior', '0'), tranche('Senior', '5000')]),
-            ),
-        ).toBe(false);
-    });
-
-    it('is false for a pool with no tranches (nothing to be full)', () => {
-        expect(poolAllTranchesFull(pool([]))).toBe(false);
-    });
-});
-
-describe('derivePoolStatus', () => {
-    it('is "Coming soon" for a pool that is not yet enabled, full or not', () => {
-        expect(derivePoolStatus(pool([tranche('Senior', '5000')], false))).toBe(
-            'Coming soon',
-        );
-        expect(derivePoolStatus(pool([tranche('Senior', '0')], false))).toBe(
-            'Coming soon',
-        );
-    });
-
-    it('is "Full" for an enabled pool with no capacity anywhere', () => {
-        expect(derivePoolStatus(pool([tranche('Senior', '0')]))).toBe('Full');
-    });
-
-    it('is "Live" for an enabled pool with capacity, or with no tranches yet', () => {
-        expect(derivePoolStatus(pool([tranche('Senior', '5000')]))).toBe('Live');
-        expect(derivePoolStatus(pool([]))).toBe('Live');
-    });
-});
-
-describe('trancheApyBounds', () => {
-    it('spans the lowest minApy and the highest maxApy across tranches', () => {
-        expect(
-            trancheApyBounds([rated('0.12', '0.12'), rated('0.185', '0.185')]),
-        ).toEqual({ min: 0.12, max: 0.185 });
-    });
-
-    it('carries a single-option strategy as an equal pair', () => {
-        expect(trancheApyBounds([rated('0.1', '0.1')])).toEqual({
-            min: 0.1,
-            max: 0.1,
-        });
-    });
-
-    it('skips zero and non-finite rates rather than dragging the range down', () => {
-        // A tranche with no fixed-term config must not turn a 10.5% range into
-        // 0–10.5%.
-        expect(
-            trancheApyBounds([rated('0', '0'), rated('0.105', '0.105')]),
-        ).toEqual({ min: 0.105, max: 0.105 });
-        expect(
-            trancheApyBounds([rated('not-a-number', 'x'), rated('0.12', '0.14')]),
-        ).toEqual({ min: 0.12, max: 0.14 });
-    });
-
-    it('is null when nothing usable remains', () => {
-        expect(trancheApyBounds([])).toBeNull();
-        expect(trancheApyBounds([rated('0', '0')])).toBeNull();
-        expect(trancheApyBounds([rated('-0.1', '-0.1')])).toBeNull();
-    });
-
-    it('is null when only ONE side is usable — never half a range', () => {
-        expect(trancheApyBounds([rated('0.12', '0')])).toBeNull();
-        expect(trancheApyBounds([rated('0', '0.12')])).toBeNull();
-    });
-});
-
-describe('netTrancheApyBounds', () => {
-    it('reproduces the spec §2.5 card range: 14–22% gross is 13–20% net', () => {
-        const bounds = netTrancheApyBounds([rated('0.14', '0.22')], FEE);
-        expect(bounds).not.toBeNull();
-        expect(bounds?.min).toBeCloseTo(0.1252, 4);
-        expect(bounds?.max).toBeCloseTo(0.196, 4);
-    });
-
-    it('puts each bound through netEffectiveApy and nothing else', () => {
-        const bounds = netTrancheApyBounds([rated('0.12', '0.185')], FEE);
-        expect(bounds).toEqual({
-            min: netEffectiveApy(0.12, FEE),
-            max: netEffectiveApy(0.185, FEE),
-        });
-    });
-
-    it('returns the gross bounds unchanged at a zero fee', () => {
-        expect(netTrancheApyBounds([rated('0.14', '0.22')], 0)).toEqual({
-            min: 0.14,
-            max: 0.22,
-        });
-    });
-
-    it('FAILS CLOSED on an out-of-domain fee — never the gross range', () => {
-        // The raw subgraph integer (1000 = 10%) and a negative fee both land
-        // here. A caller that does not KNOW the fee must not call at all;
-        // substituting 0 would overstate the rate with nothing saying so.
-        expect(netTrancheApyBounds([rated('0.14', '0.22')], 1000)).toBeNull();
-        expect(netTrancheApyBounds([rated('0.14', '0.22')], -1)).toBeNull();
-        expect(netTrancheApyBounds([rated('0.14', '0.22')], NaN)).toBeNull();
-    });
-
-    it('is null when a 100% fee leaves the lender nothing', () => {
-        expect(netTrancheApyBounds([rated('0.14', '0.22')], 100)).toBeNull();
-    });
-
-    it('is null whenever the gross range is', () => {
-        expect(netTrancheApyBounds([], FEE)).toBeNull();
-        expect(netTrancheApyBounds([rated('0', '0')], FEE)).toBeNull();
-    });
-
-    it('never inverts the range it was given', () => {
-        fc.assert(
-            fc.property(
-                fc.double({ min: 0.0001, max: 0.99, noNaN: true }),
-                fc.double({ min: 0.0001, max: 0.99, noNaN: true }),
-                fc.double({ min: 0, max: 99, noNaN: true }),
-                (a, b, feePercent) => {
-                    const bounds = netTrancheApyBounds(
-                        [
-                            rated(
-                                String(Math.min(a, b)),
-                                String(Math.max(a, b)),
-                            ),
-                        ],
-                        feePercent,
-                    );
-                    if (!bounds) return;
-                    expect(bounds.min).toBeLessThanOrEqual(bounds.max);
-                    expect(bounds.min).toBeGreaterThan(0);
-                },
-            ),
-            { numRuns: 2000 },
-        );
-    });
-});

package/src/domain/wallet-errors.test.ts

@@ -1,100 +0,0 @@
-import { isUnpredictableGas, isUserRejected } from './wallet-errors';
-
-/**
- * `isUserRejected` cases ported from kasu-ui
- * `src/lib/web3/is-user-rejected.test.ts`. `isUnpredictableGas` had no test in
- * kasu-mobile; one is written here.
- */
-
-describe('isUserRejected', () => {
-    it('detects EIP-1193 numeric code 4001', () => {
-        expect(isUserRejected({ code: 4001, message: 'whatever' })).toBe(true);
-    });
-
-    it('detects ACTION_REJECTED string code (ethers v5)', () => {
-        expect(
-            isUserRejected({ code: 'ACTION_REJECTED', message: 'rejected' }),
-        ).toBe(true);
-    });
-
-    it('detects "User rejected" message string', () => {
-        expect(isUserRejected(new Error('User rejected the request'))).toBe(
-            true,
-        );
-    });
-
-    it('detects "User denied" message string', () => {
-        expect(
-            isUserRejected(new Error('User denied transaction signature')),
-        ).toBe(true);
-    });
-
-    it('detects the ethers ACTION_REJECTED marker in a message', () => {
-        expect(
-            isUserRejected(new Error('transaction failed: ACTION_REJECTED')),
-        ).toBe(true);
-    });
-
-    it('is case-insensitive', () => {
-        expect(isUserRejected(new Error('user REJECTED the request'))).toBe(
-            true,
-        );
-    });
-
-    it('returns false for unrelated errors', () => {
-        expect(isUserRejected(new Error('Network error'))).toBe(false);
-        expect(isUserRejected(new Error('Insufficient funds'))).toBe(false);
-    });
-
-    it('returns false for null / undefined', () => {
-        expect(isUserRejected(null)).toBe(false);
-        expect(isUserRejected(undefined)).toBe(false);
-    });
-
-    it('handles non-Error throwables', () => {
-        expect(isUserRejected('user rejected')).toBe(true);
-        expect(isUserRejected('something else')).toBe(false);
-    });
-
-    it('is not fooled by a numeric code that only looks like 4001', () => {
-        expect(isUserRejected({ code: '4001' })).toBe(false);
-        expect(isUserRejected({ code: 4002 })).toBe(false);
-    });
-});
-
-describe('isUnpredictableGas', () => {
-    it('detects the ethers v5 gas-estimation revert code', () => {
-        expect(isUnpredictableGas({ code: 'UNPREDICTABLE_GAS_LIMIT' })).toBe(
-            true,
-        );
-    });
-
-    it('does not fire on a user rejection', () => {
-        expect(isUnpredictableGas({ code: 'ACTION_REJECTED' })).toBe(false);
-        expect(isUnpredictableGas({ code: 4001 })).toBe(false);
-    });
-
-    it('does not fire on the code appearing only in a message', () => {
-        // The code is the signal; a message mentioning it is not one, or a
-        // logged error string would be mistaken for a revert.
-        expect(
-            isUnpredictableGas(new Error('UNPREDICTABLE_GAS_LIMIT')),
-        ).toBe(false);
-        expect(isUnpredictableGas('UNPREDICTABLE_GAS_LIMIT')).toBe(false);
-    });
-
-    it('returns false for null / undefined and for unrelated errors', () => {
-        expect(isUnpredictableGas(null)).toBe(false);
-        expect(isUnpredictableGas(undefined)).toBe(false);
-        expect(isUnpredictableGas(new Error('Network error'))).toBe(false);
-    });
-
-    it('reads the code off an ethers error object', () => {
-        const err = Object.assign(new Error('cannot estimate gas'), {
-            code: 'UNPREDICTABLE_GAS_LIMIT',
-            reason: 'execution reverted: ERC20: insufficient allowance',
-        });
-        expect(isUnpredictableGas(err)).toBe(true);
-        expect(isUserRejected(err)).toBe(false);
-    });
-});