@kasufinance/kasu-sdk 2.4.2 → 2.6.0

package/dist/tests/sample.test.js

@@ -7,32 +7,53 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+/**
+ * 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';
-test('subgraphCall', () => __awaiter(void 0, void 0, void 0, function* () {
-    const provider = new ethers.providers.JsonRpcProvider('https://sepolia.base.org');
-    const wallet = new ethers.Wallet('dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd', provider);
-    const config = new SdkConfig({
-        subgraphUrl: 'https://api.studio.thegraph.com/query/63245/kasu-wip-sepolia/version/latest',
-        contracts: {
-            IKSULocking: '0x529A81c11ab6176c5E88670d293BB771800066a2',
-            IKSULockBonus: '0xBBfFd5F744156FFc526df12F5e09dC7b208Be740',
-            KSUToken: '0xa0f698Feb9Bc2BeA6E85eb071D5E3F59dc5bC56b',
-            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);
-    console.log(yield sdk.UserLending.getUserApyBonus('0xef38c432682ab49095e00442aaa354e955ac03a5'));
-}));
+const live = process.env.LIVE_TESTS === '1';
+(live ? describe : describe.skip)('live network — subgraph read', () => {
+    it('reads a user APY bonus through the subgraph', () => __awaiter(void 0, void 0, void 0, function* () {
+        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 = yield sdk.UserLending.getUserApyBonus('0xef38c432682ab49095e00442aaa354e955ac03a5');
+        expect(bonus).toBeDefined();
+    }));
+});
 //# sourceMappingURL=sample.test.js.map

package/dist/tests/sample.test.js.map

@@ -1 +1 @@
-{"version":3,"file":"sample.test.js","sourceRoot":"","sources":["../../src/tests/sample.test.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEjC,OAAO,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1C,IAAI,CAAC,cAAc,EAAE,GAAS,EAAE;IAC5B,MAAM,QAAQ,GAAG,IAAI,MAAM,CAAC,SAAS,CAAC,eAAe,CACjD,0BAA0B,CAC7B,CAAC;IAEF,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,MAAM,CAC5B,kEAAkE,EAClE,QAAQ,CACX,CAAC;IACF,MAAM,MAAM,GAAG,IAAI,SAAS,CAAC;QACzB,WAAW,EACP,6EAA6E;QACjF,SAAS,EAAE;YACP,WAAW,EAAE,4CAA4C;YACzD,aAAa,EAAE,4CAA4C;YAC3D,QAAQ,EAAE,4CAA4C;YACtD,WAAW,EAAE,4CAA4C;YACzD,kBAAkB,EAAE,4CAA4C;YAChE,aAAa,EAAE,4CAA4C;YAC3D,eAAe,EAAE,4CAA4C;YAC7D,kBAAkB,EAAE,4CAA4C;YAChE,QAAQ,EAAE,4CAA4C;YACtD,mBAAmB,EAAE,4CAA4C;YACjE,QAAQ,EAAE,4CAA4C;YACtD,WAAW,EAAE,4CAA4C;SAC5D;QACD,WAAW,EAAE,mCAAmC;QAChD,uBAAuB,EAAE,CAAC,EAAE,CAAC;KAChC,CAAC,CAAC;IACH,MAAM,GAAG,GAAG,IAAI,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAExC,OAAO,CAAC,GAAG,CACP,MAAM,GAAG,CAAC,WAAW,CAAC,eAAe,CACjC,4CAA4C,CAC/C,CACJ,CAAC;AACN,CAAC,CAAA,CAAC,CAAC"}
+{"version":3,"file":"sample.test.js","sourceRoot":"","sources":["../../src/tests/sample.test.ts"],"names":[],"mappings":";;;;;;;;;AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEjC,OAAO,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1C,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,KAAK,GAAG,CAAC;AAE5C,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,8BAA8B,EAAE,GAAG,EAAE;IACnE,EAAE,CAAC,6CAA6C,EAAE,GAAS,EAAE;QACzD,MAAM,QAAQ,GAAG,IAAI,MAAM,CAAC,SAAS,CAAC,eAAe,CACjD,0BAA0B,CAC7B,CAAC;QAEF,qEAAqE;QACrE,qEAAqE;QACrE,wBAAwB;QACxB,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAE9D,MAAM,MAAM,GAAG,IAAI,SAAS,CAAC;YACzB,WAAW,EACP,6EAA6E;YACjF,SAAS,EAAE;gBACP,WAAW,EAAE,4CAA4C;gBACzD,aAAa,EAAE,4CAA4C;gBAC3D,wDAAwD;gBACxD,6DAA6D;gBAC7D,uDAAuD;gBACvD,QAAQ,EAAE,4CAA4C,EAAE,iBAAiB;gBACzE,WAAW,EAAE,4CAA4C;gBACzD,kBAAkB,EAAE,4CAA4C;gBAChE,aAAa,EAAE,4CAA4C;gBAC3D,eAAe,EAAE,4CAA4C;gBAC7D,kBAAkB,EACd,4CAA4C;gBAChD,QAAQ,EAAE,4CAA4C;gBACtD,mBAAmB,EACf,4CAA4C;gBAChD,QAAQ,EAAE,4CAA4C;gBACtD,WAAW,EAAE,4CAA4C;aAC5D;YACD,WAAW,EAAE,mCAAmC;YAChD,uBAAuB,EAAE,CAAC,EAAE,CAAC;SAChC,CAAC,CAAC;QACH,MAAM,GAAG,GAAG,IAAI,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAExC,MAAM,KAAK,GAAG,MAAM,GAAG,CAAC,WAAW,CAAC,eAAe,CAC/C,4CAA4C,CAC/C,CAAC;QAEF,MAAM,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;IAChC,CAAC,CAAA,CAAC,CAAC;AACP,CAAC,CAAC,CAAC"}

package/package.json

@@ -1,12 +1,44 @@
 {
     "name": "@kasufinance/kasu-sdk",
-    "version": "2.4.2",
-    "description": "",
+    "version": "2.6.0",
+    "description": "TypeScript SDK for the Kasu Finance protocol — pool data, portfolio analytics, and KYC-gated deposits and withdrawals on Base and XDC",
+    "keywords": [
+        "kasu",
+        "defi",
+        "rwa",
+        "lending",
+        "ethers",
+        "base",
+        "xdc",
+        "sdk"
+    ],
+    "homepage": "https://github.com/Kasu-Finance/kasu-sdk#readme",
+    "bugs": {
+        "url": "https://github.com/Kasu-Finance/kasu-sdk/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/Kasu-Finance/kasu-sdk.git"
+    },
+    "license": "MIT",
+    "author": "Kasu Finance",
     "main": "dist/bundle.cjs.js",
     "module": "dist/bundle.esm.js",
     "types": "dist/index.d.ts",
+    "files": [
+        "dist",
+        "src",
+        "abis",
+        "README.md",
+        "LICENSE"
+    ],
+    "engines": {
+        "node": ">=18"
+    },
     "scripts": {
         "test": "jest --config=jest-config.ts",
+        "test:unit": "jest --config=jest-config.ts --testPathIgnorePatterns /src/tests/",
+        "test:live": "LIVE_TESTS=1 jest --config=jest-config.ts src/tests",
         "build-tc": "typechain --target ethers-v5 --out-dir src/contracts './abis/*.json'",
         "build": "eslint . && tsc --build --force tsconfig.json",
         "prepublishOnly": "npm run build && npm run rollup-build",
@@ -18,34 +50,33 @@
         "registry": "https://registry.npmjs.org/",
         "access": "public"
     },
-    "author": "",
-    "license": "ISC",
     "devDependencies": {
+        "@rollup/plugin-commonjs": "^25.0.7",
         "@rollup/plugin-node-resolve": "^15.2.3",
         "@rollup/plugin-typescript": "^11.1.6",
+        "@typechain/ethers-v5": "^11.1.2",
         "@types/jest": "^29.5.11",
         "@types/node": "^22.15.29",
         "@typescript-eslint/eslint-plugin": "^6.19.0",
+        "@typescript-eslint/parser": "^6.0.0",
+        "eslint": "^8.56.0",
         "eslint-config-prettier": "^9.1.0",
         "eslint-plugin-import": "^2.29.1",
+        "fast-check": "^4.9.0",
         "graphql": "^16.8.1",
+        "jest": "^29.7.0",
         "prettier": "^3.2.2",
         "rollup": "^4.14.3",
         "ts-jest": "^29.1.2",
+        "ts-node": "^10.9.2",
+        "tslib": "^2.6.2",
         "typechain": "^8.3.2",
         "typescript": "^5.8.3"
     },
     "dependencies": {
         "@directus/sdk": "^16.1.0",
-        "@rollup/plugin-commonjs": "^25.0.7",
-        "@typechain/ethers-v5": "^11.1.2",
-        "@typescript-eslint/parser": "^6.0.0",
         "axios": "^1.7.0",
-        "eslint": "^8.56.0",
         "ethers": "^5.7.2",
-        "graphql-request": "^6.1.0",
-        "jest": "^29.7.0",
-        "ts-node": "^10.9.2",
-        "tslib": "^2.6.2"
+        "graphql-request": "^6.1.0"
     }
 }

package/src/domain/au-minimum.test.ts

@@ -0,0 +1,371 @@
+import {
+    AU_ALPHA3,
+    AU_MIN_CUMULATIVE_BY_STABLE,
+    auMinimumRemaining,
+    auThresholdFor,
+    isAuMinimumExempt,
+    isAustralianKyc,
+    parseMinorUnits,
+} from './au-minimum';
+
+/**
+ * Ported from kasu-ui
+ * `src/features/lending/lib/au-lending-restriction.test.ts`, minus the two
+ * cases that pin toast copy — those strings stay in the applications.
+ *
+ * What these pin is the arithmetic: integer bigint minor units and a
+ * truncating parse, so no consumer can disagree with another at the
+ * 360,000 / 500,000 boundary.
+ */
+
+// 6dp on every current deployment (USDC on Base/XDC, AUDD on XDC).
+const DP = 6;
+const n = (v: string): bigint => BigInt(v);
+
+describe('isAustralianKyc', () => {
+    it('accepts the alpha-3 code in any casing, with surrounding whitespace', () => {
+        expect(isAustralianKyc('AUS')).toBe(true);
+        expect(isAustralianKyc('aus')).toBe(true);
+        expect(isAustralianKyc(' AUS ')).toBe(true);
+        expect(isAustralianKyc('Aus')).toBe(true);
+    });
+
+    it('rejects the alpha-2 code — the collapsed KYC field is alpha-3', () => {
+        // Deliberate: a bare 'AU' must NOT restrict. The KYC claim is
+        // normalised to alpha-3 before it ever reaches this rule.
+        expect(isAustralianKyc('AU')).toBe(false);
+    });
+
+    it('rejects near-misses and absent countries (fail-open)', () => {
+        expect(isAustralianKyc('AUT')).toBe(false);
+        expect(isAustralianKyc('')).toBe(false);
+        expect(isAustralianKyc(undefined)).toBe(false);
+        expect(isAustralianKyc(null)).toBe(false);
+    });
+
+    it('exports the alpha-3 constant it compares against', () => {
+        expect(AU_ALPHA3).toBe('AUS');
+    });
+});
+
+describe('auThresholdFor', () => {
+    it('returns the per-stable whole-unit minimum, case-insensitively', () => {
+        expect(auThresholdFor('USDC')).toBe(360_000);
+        expect(auThresholdFor('usdc')).toBe(360_000);
+        expect(auThresholdFor(' USDC ')).toBe(360_000);
+        expect(auThresholdFor('AUDD')).toBe(500_000);
+        expect(auThresholdFor('audd')).toBe(500_000);
+    });
+
+    it('fails open for an unlisted stable or a missing symbol', () => {
+        expect(auThresholdFor('DAI')).toBeUndefined();
+        expect(auThresholdFor(undefined)).toBeUndefined();
+        expect(auThresholdFor(null)).toBeUndefined();
+        expect(auThresholdFor('')).toBeUndefined();
+    });
+
+    it('exposes the table kasu-backend’s minimums must match', () => {
+        expect(AU_MIN_CUMULATIVE_BY_STABLE).toEqual({
+            USDC: 360_000,
+            AUDD: 500_000,
+        });
+    });
+});
+
+describe('parseMinorUnits (6dp)', () => {
+    it('parses whole and partial decimal input', () => {
+        expect(parseMinorUnits('0', DP)).toBe(n('0'));
+        expect(parseMinorUnits('1', DP)).toBe(n('1000000'));
+        // Mid-typing states an amount field really produces.
+        expect(parseMinorUnits('10.', DP)).toBe(n('10000000'));
+        expect(parseMinorUnits('.5', DP)).toBe(n('500000'));
+        expect(parseMinorUnits('1.5', DP)).toBe(n('1500000'));
+    });
+
+    it('TRUNCATES excess precision — a position can never be inflated into passing', () => {
+        expect(parseMinorUnits('1.23456789', DP)).toBe(n('1234567'));
+    });
+
+    it('returns null for empty, non-numeric, negative and absent input', () => {
+        expect(parseMinorUnits('', DP)).toBeNull();
+        expect(parseMinorUnits('   ', DP)).toBeNull();
+        expect(parseMinorUnits('abc', DP)).toBeNull();
+        expect(parseMinorUnits('-5', DP)).toBeNull();
+        // A lone separator matches the shape but carries no digits.
+        expect(parseMinorUnits('.', DP)).toBeNull();
+        expect(parseMinorUnits(null, DP)).toBeNull();
+        expect(parseMinorUnits(undefined, DP)).toBeNull();
+    });
+
+    it('accepts numbers as well as strings', () => {
+        expect(parseMinorUnits(360_000, DP)).toBe(n('360000000000'));
+        expect(parseMinorUnits(0, DP)).toBe(n('0'));
+    });
+});
+
+// `address` and `exemptAddresses` are required keys on AuMinimumInput (a
+// refactor must not be able to drop either silently), so the shared fixture
+// supplies the un-exempted defaults and the exemption cases override them.
+const BASE = {
+    stableSymbol: 'USDC',
+    decimals: DP,
+    address: undefined,
+    exemptAddresses: undefined,
+} as const;
+
+describe('auMinimumRemaining — fail-open cases return 0 (no raised minimum)', () => {
+    it('is 0 when the KYC country is absent', () => {
+        expect(
+            auMinimumRemaining({
+                ...BASE,
+                country: undefined,
+                existingDeposited: '0',
+            }),
+        ).toBe(0);
+        expect(
+            auMinimumRemaining({
+                ...BASE,
+                country: null,
+                existingDeposited: '0',
+            }),
+        ).toBe(0);
+    });
+
+    it('is 0 for a non-Australian lender', () => {
+        expect(
+            auMinimumRemaining({
+                ...BASE,
+                country: 'USA',
+                existingDeposited: '0',
+            }),
+        ).toBe(0);
+    });
+
+    it('is 0 on a deployment whose stable has no configured threshold', () => {
+        expect(
+            auMinimumRemaining({
+                ...BASE,
+                stableSymbol: 'DAI',
+                country: 'AUS',
+                existingDeposited: '0',
+            }),
+        ).toBe(0);
+    });
+});
+
+describe('auMinimumRemaining — Australian lender', () => {
+    it('demands the FULL threshold while the position is unknown (strict-until-loaded)', () => {
+        // `undefined` is not a zero position — it is an unread one. Treating
+        // it as 0 keeps the floor at its strictest until the read lands, so
+        // the field never advertises a minimum lower than the backend accepts.
+        expect(
+            auMinimumRemaining({
+                ...BASE,
+                country: 'AUS',
+                existingDeposited: undefined,
+            }),
+        ).toBe(360_000);
+    });
+
+    it('is 0 once the existing position exactly meets the threshold (inclusive)', () => {
+        expect(
+            auMinimumRemaining({
+                ...BASE,
+                country: 'AUS',
+                existingDeposited: '360000',
+            }),
+        ).toBe(0);
+    });
+
+    it('is 0 once the existing position exceeds the threshold', () => {
+        expect(
+            auMinimumRemaining({
+                ...BASE,
+                country: 'AUS',
+                existingDeposited: '400000',
+            }),
+        ).toBe(0);
+    });
+
+    it('returns the remainder for a partial position', () => {
+        expect(
+            auMinimumRemaining({
+                ...BASE,
+                country: 'AUS',
+                existingDeposited: '120000',
+            }),
+        ).toBe(240_000);
+    });
+
+    it('keeps sub-unit precision — one minor unit short still demands one minor unit', () => {
+        // 359,999.999999 lent → 0.000001 USDC left to reach 360,000. The
+        // bigint arithmetic must not round that away into a 0 (unrestricted).
+        expect(
+            auMinimumRemaining({
+                ...BASE,
+                country: 'AUS',
+                existingDeposited: '359999.999999',
+            }),
+        ).toBe(0.000001);
+    });
+
+    it('accepts a numeric existing position, not just a string', () => {
+        expect(
+            auMinimumRemaining({
+                ...BASE,
+                country: 'AUS',
+                existingDeposited: 120_000,
+            }),
+        ).toBe(240_000);
+    });
+
+    it('uses the 500,000 threshold on AUDD deployments', () => {
+        expect(
+            auMinimumRemaining({
+                ...BASE,
+                stableSymbol: 'AUDD',
+                country: 'AUS',
+                existingDeposited: 0,
+            }),
+        ).toBe(500_000);
+    });
+});
+
+// Deployment configuration the caller supplies — see `isAuMinimumExempt`. The
+// real list is never shipped in this public package; these are stand-ins.
+const EXEMPT_CHECKSUMMED = '0x1111111111111111111111111111111111111111';
+const EXEMPT_LOWER = EXEMPT_CHECKSUMMED.toLowerCase();
+const OTHER_EXEMPT = '0x2222222222222222222222222222222222222222';
+const NOT_EXEMPT = '0x3333333333333333333333333333333333333333';
+const LIST: readonly string[] = [EXEMPT_LOWER, OTHER_EXEMPT.toLowerCase()];
+
+describe('isAuMinimumExempt', () => {
+    it('matches a listed wallet in any casing, with surrounding whitespace', () => {
+        expect(isAuMinimumExempt(EXEMPT_CHECKSUMMED, LIST)).toBe(true);
+        expect(isAuMinimumExempt(EXEMPT_LOWER, LIST)).toBe(true);
+        expect(isAuMinimumExempt(EXEMPT_LOWER.toUpperCase(), LIST)).toBe(true);
+        expect(isAuMinimumExempt(`  ${OTHER_EXEMPT}  `, LIST)).toBe(true);
+    });
+
+    it('matches a list entry stored in mixed case too', () => {
+        // The rule normalises both sides, so a caller that reads its list
+        // straight out of configuration cannot be caught out by casing.
+        expect(
+            isAuMinimumExempt(EXEMPT_LOWER, [EXEMPT_CHECKSUMMED.toUpperCase()]),
+        ).toBe(true);
+    });
+
+    it('fails CLOSED on anything unlisted or not a string', () => {
+        expect(isAuMinimumExempt(NOT_EXEMPT, LIST)).toBe(false);
+        expect(isAuMinimumExempt('', LIST)).toBe(false);
+        expect(isAuMinimumExempt('   ', LIST)).toBe(false);
+        expect(isAuMinimumExempt(undefined, LIST)).toBe(false);
+        expect(isAuMinimumExempt(null, LIST)).toBe(false);
+        // A prefix of, or an extension to, a listed address is another wallet.
+        expect(isAuMinimumExempt(EXEMPT_LOWER.slice(0, -1), LIST)).toBe(false);
+        expect(isAuMinimumExempt(`${EXEMPT_LOWER}00`, LIST)).toBe(false);
+    });
+
+    it('fails CLOSED when no list was supplied', () => {
+        expect(isAuMinimumExempt(EXEMPT_LOWER, undefined)).toBe(false);
+        expect(isAuMinimumExempt(EXEMPT_LOWER, null)).toBe(false);
+        expect(isAuMinimumExempt(EXEMPT_LOWER, [])).toBe(false);
+    });
+});
+
+describe('auMinimumRemaining — named-address exemption', () => {
+    it('is 0 for an exempt wallet that would otherwise owe the full threshold', () => {
+        for (const address of [
+            EXEMPT_CHECKSUMMED,
+            EXEMPT_LOWER,
+            OTHER_EXEMPT,
+        ]) {
+            expect(
+                auMinimumRemaining({
+                    ...BASE,
+                    country: 'AUS',
+                    address,
+                    exemptAddresses: LIST,
+                    existingDeposited: 0,
+                }),
+            ).toBe(0);
+        }
+    });
+
+    it('is 0 on AUDD too, where the threshold is the larger 500,000', () => {
+        expect(
+            auMinimumRemaining({
+                ...BASE,
+                stableSymbol: 'AUDD',
+                country: 'AUS',
+                address: EXEMPT_LOWER,
+                exemptAddresses: LIST,
+                existingDeposited: 0,
+            }),
+        ).toBe(0);
+    });
+
+    it('overrides an UNKNOWN position — the strict full-threshold case', () => {
+        // `undefined` is what a caller passes while the on-chain read is in
+        // flight, and it normally yields the whole threshold. An exemption
+        // outranks it, so an exempt lender never sees a floor that later drops.
+        expect(
+            auMinimumRemaining({
+                ...BASE,
+                country: 'AUS',
+                address: EXEMPT_LOWER,
+                exemptAddresses: LIST,
+                existingDeposited: undefined,
+            }),
+        ).toBe(0);
+    });
+
+    it('leaves a non-exempt Australian on the full threshold', () => {
+        expect(
+            auMinimumRemaining({
+                ...BASE,
+                country: 'AUS',
+                address: NOT_EXEMPT,
+                exemptAddresses: LIST,
+                existingDeposited: 0,
+            }),
+        ).toBe(360_000);
+    });
+
+    it('treats an absent address, or an absent list, as NOT exempt', () => {
+        // Both keys are required; either VALUE may be absent, and when it is
+        // the rule applies exactly as it did before exemptions existed.
+        for (const address of [undefined, null]) {
+            expect(
+                auMinimumRemaining({
+                    ...BASE,
+                    country: 'AUS',
+                    address,
+                    exemptAddresses: LIST,
+                    existingDeposited: 0,
+                }),
+            ).toBe(360_000);
+        }
+        expect(
+            auMinimumRemaining({
+                ...BASE,
+                country: 'AUS',
+                address: EXEMPT_LOWER,
+                exemptAddresses: undefined,
+                existingDeposited: 0,
+            }),
+        ).toBe(360_000);
+    });
+
+    it('is 0 for a non-Australian at an exempt address, as it always was', () => {
+        expect(
+            auMinimumRemaining({
+                ...BASE,
+                country: 'FRA',
+                address: EXEMPT_LOWER,
+                exemptAddresses: LIST,
+                existingDeposited: 0,
+            }),
+        ).toBe(0);
+    });
+});