@kasufinance/kasu-sdk 2.5.0 → 2.6.0

package/dist/bundle.esm.js

@@ -15719,6 +15719,43 @@ function filterArray(array, id_in) {
     }
 }
 
+/**
+ * The error a CMS-only call raises on a deployment configured without
+ * Directus. Named so a caller can match on it rather than on the message.
+ */
+const NO_DIRECTUS_URL_MESSAGE = 'Kasu: this call needs Directus, but the SDK was configured without a ' +
+    '`directusUrl`. On-chain data (pools, tranches, positions, requests) ' +
+    'works without one; CMS content does not.';
+/**
+ * Build the Directus client, or a stand-in that refuses clearly.
+ *
+ * `directusUrl` is documented optional, and most of the SDK genuinely does not
+ * need it — pools, tranches, positions and request history all come from the
+ * subgraph and the chain. But `createDirectus('')` throws `Invalid URL` inside
+ * the constructor, so omitting the URL used to make the whole SDK
+ * unconstructable rather than merely CMS-less.
+ *
+ * With no URL, the services skip Directus where they can degrade (pool
+ * descriptions, images and Directus pool names simply do not appear, and the
+ * raw subgraph names are used instead), and a call that exists ONLY to read
+ * CMS content rejects with `NO_DIRECTUS_URL_MESSAGE` — a sentence that says
+ * what to configure, rather than a `null` dereference thrown from inside a
+ * vendor SDK.
+ */
+function createDirectusClient(directusUrl) {
+    if (directusUrl) {
+        return le(directusUrl)
+            .with(ne())
+            .with(Zp());
+    }
+    const refuse = () => {
+        throw new Error(NO_DIRECTUS_URL_MESSAGE);
+    };
+    // A stand-in, not a client: every entry point the services use goes
+    // through `request`, so refusing there covers all of them.
+    return { request: refuse };
+}
+
 const getPoolOverviewQuery = (ids) => gql `
     query getAllPoolOverview($epochId: String!, $unusedPools: [String]!) {
         lendingPools(
@@ -15874,15 +15911,7 @@ class DataService {
         this._kasuConfig = _kasuConfig;
         this._externalTvlAbi = KasuPoolExternalTVLAbi__factory.connect(_kasuConfig.contracts.ExternalTVL, signerOrProvider);
         this._graph = new GraphQLClient(_kasuConfig.subgraphUrl);
-        if (_kasuConfig.directusUrl) {
-            this._directus = le(_kasuConfig.directusUrl)
-                .with(ne())
-                .with(Zp());
-        }
-        else {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
-            this._directus = null;
-        }
+        this._directus = createDirectusClient(_kasuConfig.directusUrl);
     }
     getUrlFromFile(fileName) {
         return `${this._kasuConfig.directusUrl}assets/${fileName}`;
@@ -17136,9 +17165,7 @@ class UserLending {
         this._clearingCoordinatorAbi = IClearingCoordinatorAbi__factory.connect(_kasuConfig.contracts.ClearingCoordinator, signerOrProvider);
         this._systemVariablesAbi = ISystemVariablesAbi__factory.connect(_kasuConfig.contracts.SystemVariables, signerOrProvider);
         this._dataService = new DataService(_kasuConfig, signerOrProvider);
-        this._directus = le(_kasuConfig.directusUrl)
-            .with(ne())
-            .with(Zp());
+        this._directus = createDirectusClient(_kasuConfig.directusUrl);
     }
     getUserTotalPendingAndActiveDepositedAmount(user) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -17256,9 +17283,14 @@ class UserLending {
                     unusedPools: this._kasuConfig.UNUSED_LENDING_POOL_IDS,
                     epochId,
                 }),
-                this._directus.request(bs('PoolOverview', {
-                    fields: ['id', 'poolName', 'subheading'],
-                })),
+                // Directus supplies the display pool NAME only; without it the
+                // raw subgraph name is used, which is what the fallback below
+                // already does for a pool with no CMS entry.
+                this._kasuConfig.directusUrl
+                    ? this._directus.request(bs('PoolOverview', {
+                        fields: ['id', 'poolName', 'subheading'],
+                    }))
+                    : [],
             ]);
             const retn = [];
             for (const userRequest of subgraphResult.userRequests) {
@@ -24293,7 +24325,13 @@ const CHAIN_CONFIGS = {
             ClearingCoordinator: '',
             ExternalTVL: '',
         },
-        subgraphUrl: 'https://api.goldsky.com/api/public/project_cmgzlpxm300765np2a19421om/subgraphs/kasu-plume/prod',
+        // The frozen Plume history is indexed on the LEGACY Goldsky project,
+        // not the one the live chains use: the same path under the current
+        // project 404s. Verified 2026-09-05 — this URL answers
+        // `{ lendingPools { id name } }` with the three Plume pools; the
+        // current-project spelling returns HTTP 404. Note the `/gn` suffix,
+        // which the current project's URLs do not carry.
+        subgraphUrl: 'https://api.goldsky.com/api/public/project_cm9t3064xeuyn01tgctdo3c17/subgraphs/kasu-plume/prod/gn',
         directusUrl: 'https://kasu-finance.directus.app/',
         unusedPoolIds: [],
         poolMetadataMapping: undefined,
@@ -24833,6 +24871,214 @@ class StrategiesFacade {
     }
 }
 
+var UserRequestStatus;
+(function (UserRequestStatus) {
+    UserRequestStatus["REQUESTED"] = "Requested";
+    UserRequestStatus["PROCESSING"] = "Processing";
+    UserRequestStatus["PROCESSED"] = "Processed";
+})(UserRequestStatus || (UserRequestStatus = {}));
+
+/**
+ * Events that represent a lender SUBMISSION into the bundle. A dNFT position
+ * aggregates every submission the lender made into the same pool/tranche this
+ * cycle: the first is `Initiated`, each subsequent top-up is `Increased`.
+ * Everything else on the timeline (Accepted / Rejected / Cancelled /
+ * Reallocated / Forced) is an OUTCOME, not a request, and must not be counted.
+ */
+const SUBMISSION_EVENTS = new Set(['Initiated', 'Increased']);
+/**
+ * The submissions bundled into one dNFT-aggregate request row, input order
+ * preserved — one loan agreement per submission.
+ */
+function submissionEvents(events) {
+    return events.filter((e) => SUBMISSION_EVENTS.has(e.requestType));
+}
+/** Count the submissions bundled into one dNFT-aggregate request row. */
+function countSubmissions(events) {
+    return submissionEvents(events).length;
+}
+/**
+ * Timestamp of the FIRST submission in the bundle. Falls back to `fallback`
+ * when the `Initiated` event has not indexed yet — the caller decides what
+ * that is (kasu-ui passes the request's own timestamp).
+ */
+function firstSubmissionTimestamp(events, fallback) {
+    const submissions = submissionEvents(events);
+    if (submissions.length === 0)
+        return fallback;
+    return submissions.reduce((min, e) => (e.timestamp < min ? e.timestamp : min), Infinity);
+}
+/**
+ * Has THIS request's cycle closed? — the single open/closed signal behind the
+ * status vocabulary and behind Cancel.
+ *
+ * `request.canCancel` is the SDK's `isCancelable(status, poolId)` —
+ * `status !== 'Processed' && !isLendingPoolClearingPending(pool)`. It is
+ * per-POOL and reads the same condition the contract enforces on the cancel
+ * call — but it reads it ONCE, when the request was fetched. Nothing about
+ * this value is live, so a client that holds a request across a cycle close
+ * must refetch before acting on it.
+ *
+ * The raw subgraph `status` must NOT feed this: `'Processing'` is a STICKY
+ * historical marker set on the first partial fill and never reset, so gating
+ * on it would freeze a partly-filled request in Processing forever. A global
+ * settlement clock is equally wrong here — it is blind to whether THIS
+ * request's pool is already clearing.
+ */
+function isCycleClosed(request) {
+    return !request.canCancel;
+}
+const isCancelled = (events) => events.some((e) => e.requestType === 'Cancelled');
+const isForced = (events) => events.some((e) => e.requestType === 'Forced');
+const initiatedEvent = (events) => events.find((e) => e.requestType === 'Initiated');
+/**
+ * Subgraph behaviour: when a request is cancelled, the on-request
+ * `requestedAmount` field is reset to 0 (the lender's effective balance is
+ * restored). The original amount survives on the `Initiated` event's
+ * `assetAmount`. Recover from there so cancelled rows still carry the amount
+ * the lender originally asked for.
+ */
+const initiatedAmountOf = (events) => {
+    const initiated = initiatedEvent(events);
+    return initiated ? Number(initiated.assetAmount || '0') : 0;
+};
+/**
+ * A deposit is REALLOCATED when the timeline carries a `Reallocated` event, or
+ * an `Accepted` event into a tranche other than the one requested.
+ */
+const findReallocation = (events, originalTrancheId) => events.find((e) => e.requestType === 'Reallocated' ||
+    (e.requestType === 'Accepted' &&
+        e.trancheId.toLowerCase() !==
+            originalTrancheId.toLowerCase()));
+/** kasu-ui's `num`: an absent or unparseable figure reads as 0. */
+const num = (str) => {
+    const n = Number(str !== null && str !== void 0 ? str : '0');
+    return Number.isFinite(n) ? n : 0;
+};
+/** The same parse, keeping "the subgraph reported nothing" distinct from 0. */
+const numOrNull = (str) => {
+    if (str === undefined || str === null || str.trim() === '')
+        return null;
+    const n = Number(str);
+    return Number.isFinite(n) ? n : null;
+};
+/**
+ * Convert a `UserRequest` into a `RequestState`. Pure — no clock, no network,
+ * no copy.
+ *
+ * BRANCH ORDER (this IS the behaviour; it reproduces kasu-ui's
+ * `deriveTransactionView` check for check):
+ *
+ *   1. a `Cancelled` event                      → `cancelled`, neutral, 0
+ *   2. a withdrawal with a `Forced` event       → `forced`, outflow, −accepted
+ *   3. a reallocated deposit                    → `reallocated`, inflow, +accepted
+ *   4. a withdrawal partly filled with a LIVE
+ *      remainder (cycle still open)             → `partial`, outflow, −accepted
+ *   5. resolved (`status === 'Processed'`):
+ *        withdrawal, partly filled              → `partial`, outflow, −accepted
+ *        withdrawal, fully filled               → `complete`, outflow, −accepted
+ *        deposit, nothing accepted              → `rejected`, neutral, 0
+ *        deposit, part rejected                 → `partial`, inflow, +accepted
+ *        deposit, fully accepted                → `complete`, inflow, +accepted
+ *   6. otherwise                                → `pending`, ±requested
+ *
+ * `cancelled` is reachable ONLY from branch 1 — a Cancelled EVENT. No
+ * processing or resolved state can derive it.
+ *
+ * Branch 4 is checked BEFORE the resolved branch and gates on `isCycleClosed`
+ * (i.e. `canCancel`), never on the sticky raw status: a withdrawal that was
+ * partly filled returns to the queue with a live Cancel, and reading the raw
+ * status would strand it.
+ *
+ * WHAT THE APPLICATION STILL OWNS: the status word and the detail line beneath
+ * it; the tranche display rename (`getTrancheDisplayName` on `trancheName`,
+ * and on the reallocation destination read off `request.events`); the pool-name
+ * split; the amount format. The "view loan agreement" affordance is a fact, and
+ * it follows from two fields already here —
+ * `requestType === 'Deposit' && statusCode !== 'cancelled' && statusCode !== 'rejected'`
+ * — because neither a cancelled nor a fully-rejected deposit ever issued one,
+ * and withdrawals sign no agreement at all.
+ */
+function deriveRequestState(request) {
+    var _a, _b, _c;
+    const isWithdrawal = request.requestType === 'Withdrawal';
+    const cancelled = isCancelled(request.events);
+    // Cancelled requests have `requestedAmount` zeroed on the request itself;
+    // pull the original value from the Initiated event so the row still
+    // carries "100 cancelled" instead of "0 cancelled".
+    const requested = cancelled
+        ? num(request.requestedAmount) || initiatedAmountOf(request.events)
+        : num(request.requestedAmount);
+    const accepted = num(request.acceptedAmount);
+    const rejected = num(request.rejectedAmount);
+    const forced = isWithdrawal && isForced(request.events);
+    const reallocation = !isWithdrawal && findReallocation(request.events, request.trancheId);
+    const initiated = initiatedEvent(request.events);
+    const base = {
+        id: request.id,
+        contractId: (_a = initiated === null || initiated === void 0 ? void 0 : initiated.id) !== null && _a !== void 0 ? _a : '',
+        poolId: request.lendingPool.id.toLowerCase(),
+        poolName: request.lendingPool.name,
+        trancheName: request.trancheName,
+        trancheId: request.trancheId,
+        fixedTermConfigId: (_c = (_b = request.fixedTermConfig) === null || _b === void 0 ? void 0 : _b.configId) !== null && _c !== void 0 ? _c : '0',
+        requestType: request.requestType,
+        rawStatus: request.status,
+        requestedAmount: requested,
+        acceptedAmount: numOrNull(request.acceptedAmount),
+        initiatedAmount: initiated
+            ? initiatedAmountOf(request.events)
+            : null,
+        submissionCount: countSubmissions(request.events),
+        // `firstSubmissionTimestamp` needs a fallback it will never use here:
+        // the bundle is non-empty on every path that reaches the call.
+        firstSubmissionTimestamp: countSubmissions(request.events) === 0
+            ? null
+            : firstSubmissionTimestamp(request.events, 0),
+        cycleClosed: isCycleClosed(request),
+        canCancel: request.canCancel,
+    };
+    // 1. Cancelled wins over everything — the ONLY path to `cancelled`.
+    if (cancelled) {
+        return Object.assign(Object.assign({}, base), { kind: 'neutral', amount: 0, statusCode: 'cancelled' });
+    }
+    // 2. Forced withdrawal (credit originator returned funds early).
+    if (forced) {
+        return Object.assign(Object.assign({}, base), { kind: 'outflow', amount: -accepted, statusCode: 'forced' });
+    }
+    // 3. Reallocated deposit (accepted into a different lending option).
+    if (reallocation) {
+        return Object.assign(Object.assign({}, base), { kind: 'inflow', amount: accepted, statusCode: 'reallocated' });
+    }
+    // 4. Withdrawal partly filled with a LIVE remainder: the request returns
+    // to the queue with a live Cancel. Checked BEFORE the resolved branch and
+    // via `isCycleClosed`, never via the sticky raw status.
+    if (isWithdrawal &&
+        accepted > 0 &&
+        accepted < requested &&
+        !isCycleClosed(request)) {
+        return Object.assign(Object.assign({}, base), { kind: 'outflow', amount: -accepted, statusCode: 'partial' });
+    }
+    // 5. Resolved — a rejection IS a resolution.
+    if (request.status === UserRequestStatus.PROCESSED) {
+        if (isWithdrawal) {
+            const partly = accepted < requested;
+            return Object.assign(Object.assign({}, base), { kind: 'outflow', amount: -accepted, statusCode: partly ? 'partial' : 'complete' });
+        }
+        // Deposit: full reject vs partial vs full accept.
+        if (accepted === 0) {
+            return Object.assign(Object.assign({}, base), { kind: 'neutral', amount: 0, statusCode: 'rejected' });
+        }
+        if (rejected > 0) {
+            return Object.assign(Object.assign({}, base), { kind: 'inflow', amount: accepted, statusCode: 'partial' });
+        }
+        return Object.assign(Object.assign({}, base), { kind: 'inflow', amount: accepted, statusCode: 'complete' });
+    }
+    // 6. Unresolved. `cycleClosed` tells the caller whether to render its
+    // "queued" or its "processing" word; the code is the same either way.
+    return Object.assign(Object.assign({}, base), { kind: isWithdrawal ? 'outflow' : 'inflow', amount: isWithdrawal ? -requested : requested, statusCode: 'pending' });
+}
+
 /**
  * High-level facade for querying a user's portfolio, positions, and history.
  *
@@ -24875,6 +25121,28 @@ class PortfolioFacade {
             return yield this._userLending.getUserRequests(userAddress, currentEpoch);
         });
     }
+    /**
+     * The same history, already derived into `RequestState` rows — status
+     * code, kind, signed amount, the cancelled-amount recovery, the bundled
+     * submission count and the cycle-open signal.
+     *
+     * ```ts
+     * const rows = await kasu.portfolio.getRequestStates('0xUser...');
+     * rows.filter((r) => r.statusCode === 'pending');
+     * ```
+     *
+     * Every application derives this from `getTransactionHistory` anyway, and
+     * the derivation is the part they were each getting subtly differently.
+     * Words are still the caller's: render `statusCode` in your own
+     * vocabulary, and call `getTrancheDisplayName` on `trancheName` at the
+     * view boundary.
+     */
+    getRequestStates(userAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requests = yield this.getTransactionHistory(userAddress);
+            return requests.map(deriveRequestState);
+        });
+    }
 }
 
 /**
@@ -25123,6 +25391,160 @@ function fetchUnusedPoolIds() {
     });
 }
 
+/**
+ * The AU cumulative-lending minimum — the numeric half.
+ *
+ * RULE: a lender whose verified KYC country is Australia may only lend when
+ * their existing deposited position on THIS deployment, plus the amount they
+ * are asking for, reaches the deployment's threshold.
+ *
+ * This is UX PRE-VALIDATION ONLY. kasu-backend enforces the rule
+ * authoritatively at contract generation and refuses with HTTP 403
+ * `AU_WHOLESALE_MINIMUM_NOT_MET`; a lender who gets past this check is still
+ * stopped there. What these helpers exist for is to raise the amount field's
+ * minimum so the lender learns the rule while typing rather than at the end.
+ *
+ * FAIL-OPEN by design: an absent or unknown country is NOT restricted, and an
+ * unlisted stable symbol has no threshold. An UNKNOWN existing position is
+ * treated as 0 — strict, so the floor is never advertised lower than the
+ * backend will accept, and it relaxes once the position loads.
+ *
+ * Arithmetic is integer bigint in minor units (10^decimals) so no two
+ * consumers can disagree at the boundary. Parsing TRUNCATES, never rounds up —
+ * a position can never be inflated into passing. `BigInt(...)` calls only, no
+ * bigint literals, so consumers on an older target still compile.
+ *
+ * Lifted from kasu-ui's `features/lending/lib/au-lending-restriction.ts`. The
+ * two toast strings that live there are copy and stay in the applications.
+ */
+const ZERO = BigInt(0);
+/** ISO 3166-1 alpha-3 for Australia — the collapsed KYC country field. */
+const AU_ALPHA3 = 'AUS';
+/**
+ * Is this the Australian KYC country? Case-insensitive and
+ * whitespace-tolerant. Anything that is not a string — including the
+ * `undefined` of an unloaded KYC record — is not restricted (fail-open).
+ *
+ * The alpha-2 `'AU'` deliberately does NOT match: the KYC country reaching
+ * this rule is normalised to alpha-3 upstream, and a bare two-letter code
+ * here means something else went wrong.
+ */
+function isAustralianKyc(country) {
+    if (typeof country !== 'string')
+        return false;
+    return country.trim().toUpperCase() === AU_ALPHA3;
+}
+/**
+ * Minimum CUMULATIVE position, in WHOLE stable units, keyed on the
+ * deployment's stable-asset symbol (a property of the currency, not the
+ * chain). Must match kasu-backend's table exactly.
+ */
+const AU_MIN_CUMULATIVE_BY_STABLE = {
+    USDC: 360000,
+    AUDD: 500000,
+};
+/**
+ * Threshold in whole units, or `undefined` for an unlisted stable — a
+ * deployment whose currency has no configured minimum is unrestricted.
+ */
+function auThresholdFor(symbol) {
+    if (typeof symbol !== 'string')
+        return undefined;
+    return AU_MIN_CUMULATIVE_BY_STABLE[symbol.trim().toUpperCase()];
+}
+/**
+ * Is this wallet released from the minimum entirely, whatever its country,
+ * stable or position says?
+ *
+ * `exemptAddresses` is DEPLOYMENT CONFIGURATION the caller supplies, not a
+ * constant of this package. kasu-sdk is published publicly; the exempt list is
+ * a compliance carve-out naming particular lender wallets, so it does not
+ * belong in a public tarball. Read it from wherever the application keeps its
+ * deployment configuration, and keep it identical to kasu-backend's
+ * `AU_WHOLESALE_EXEMPT_ADDRESSES` — that is where the rule is actually
+ * enforced. An address exempt here but not there sees no raised minimum in the
+ * form and is refused at the end, which is worse than not exempting it at all.
+ *
+ * The address matched must be the CONNECTED wallet — the one that owns the KYC
+ * record and signs the agreement request. kasu-backend verifies that signature
+ * before the gate, so an exemption cannot be claimed by asserting someone
+ * else's address; it takes their private key. Never match a "view as" address.
+ *
+ * Comparison is case-insensitive and whitespace-tolerant. Anything that is not
+ * a string is NOT exempt (fail closed), and so is anything when the list is
+ * absent.
+ */
+function isAuMinimumExempt(address, exemptAddresses) {
+    if (typeof address !== 'string' || !exemptAddresses)
+        return false;
+    const needle = address.trim().toLowerCase();
+    return exemptAddresses.some((a) => a.trim().toLowerCase() === needle);
+}
+const DECIMAL_RE = /^(\d+)?(?:\.(\d*))?$/;
+/**
+ * Truncating, partial-input-tolerant decimal → minor-unit parse.
+ * `'10.'` → `10000000n` · `'1.23456789'` → `1234567n` (truncated at 6dp).
+ * `''` / `'abc'` / negative / null → `null`.
+ *
+ * Tolerant of mid-typing states because it runs on an amount field as the
+ * lender types, and truncating because rounding up would let a position that
+ * is a fraction short read as passing.
+ */
+function parseMinorUnits(value, decimals) {
+    if (value === null || value === undefined)
+        return null;
+    const raw = typeof value === 'number' ? String(value) : value.trim();
+    if (!raw)
+        return null;
+    const match = DECIMAL_RE.exec(raw);
+    if (!match || (!match[1] && !match[2]))
+        return null;
+    // Both capture groups are optional, so either can be absent at runtime.
+    // A fractional group that matched EMPTY ('10.') is not absent, and the
+    // destructuring defaults leave it alone — only `undefined` takes them.
+    const [, whole = '0', fracDigits = ''] = match;
+    const frac = fracDigits.slice(0, decimals).padEnd(decimals, '0');
+    return BigInt(whole + frac);
+}
+/**
+ * The amount, in WHOLE stable units, an Australian lender still needs in order
+ * to reach the deployment's cumulative minimum. Apply it as the amount field's
+ * floor via `max(trancheMin, auMinimumRemaining(...))`.
+ *
+ * Returns 0 for everyone the rule does not restrict (fail-open), 0 for an
+ * exempt address, and 0 once the lender's existing position already satisfies
+ * the threshold.
+ *
+ * The exemption is tested FIRST and unconditionally: an exempt wallet has no
+ * minimum whatever its country, stable or position says. kasu-backend
+ * deliberately tests country first and the exemption second — the two orders
+ * are not in conflict, both return "no minimum" for the same inputs. There,
+ * the exemption sets a flag that drives a compliance log, so it must not fire
+ * for a lender the rule never engaged for. Here nothing is logged, so
+ * exemption-first is preferred: it makes this function right on its own,
+ * whatever country a caller happens to pass.
+ */
+function auMinimumRemaining(input) {
+    var _a, _b;
+    if (isAuMinimumExempt(input.address, input.exemptAddresses))
+        return 0;
+    if (!isAustralianKyc(input.country))
+        return 0;
+    const threshold = auThresholdFor(input.stableSymbol);
+    if (threshold === undefined)
+        return 0;
+    const { existingDeposited, decimals } = input;
+    // A table threshold always parses; `?? ZERO` keeps the rule fail-open
+    // rather than asserting, so an unparseable one yields no minimum at all.
+    const thresholdMinor = (_a = parseMinorUnits(threshold, decimals)) !== null && _a !== void 0 ? _a : ZERO;
+    const existingMinor = (_b = parseMinorUnits(existingDeposited, decimals)) !== null && _b !== void 0 ? _b : ZERO;
+    const remaining = thresholdMinor - existingMinor;
+    if (remaining <= ZERO)
+        return 0;
+    const base = BigInt('1' + '0'.repeat(decimals));
+    return Number(remaining / base) + Number(remaining % base) / Number(base);
+}
+
 // Fallbacks if the selected tranche's on-chain min/max are 0 / NaN (some
 // "coming soon" pools haven't been configured yet).
 const MIN_LENDING_AMOUNT_FALLBACK = 500;
@@ -25250,6 +25672,282 @@ function getInstitutionalLender(originator) {
     return originator.name === APXIUM.name ? RIXON_CAPITAL : null;
 }
 
+/** Narrow the backend's loose `contractType` string to the encoded union. */
+function asContractType(raw) {
+    return raw === 'exempt' ? 'exempt' : 'retail';
+}
+/**
+ * Parse the server's JSON-string `formattedMessage` into a tree. Returns
+ * `null` on parse failure so a renderer can fall back to the plaintext.
+ */
+function parseFormattedMessage(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object')
+            return parsed;
+        return null;
+    }
+    catch (_a) {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// The on-chain `depositData` blob
+// ---------------------------------------------------------------------------
+/**
+ * Pack the contract version and type into the `versionType` word.
+ *
+ * ```
+ * high byte = contract version (>= 1)
+ * low byte  = 0 for retail, 1 for exempt
+ * ```
+ */
+function buildContractVersionType(contractVersion, contractType) {
+    return (contractVersion << 8) + (contractType === 'retail' ? 0 : 1);
+}
+/**
+ * Build the on-chain `depositData` blob that `requestDepositWithKyc` expects.
+ *
+ * The KasuController decodes the bytes as
+ * `(bytes signature, uint256 timestamp, uint256 versionType)` and uses the
+ * embedded acceptance signature to verify — retrospectively, via the
+ * agreements service `/contract/resolve` — that the lender signed the
+ * loan-contract text. The ABI tuple and the packing are consensus-critical:
+ * these bytes go on chain.
+ *
+ * kasu-ui encodes this with viem, kasu-mobile with ethers v5 (viem is not
+ * available on Expo). This is the ethers v5 implementation, and
+ * `loan-contract.test.ts` pins its output byte-for-byte against fixtures
+ * produced by the viem version, so the two apps can never diverge here.
+ *
+ * @param args.signature EIP-191 signature from the lender accepting
+ *   `contractMessage`, as a 0x-prefixed hex string.
+ * @param args.timestamp ms-epoch from the contract response.
+ */
+function encodeDepositData(args) {
+    const versionType = buildContractVersionType(args.contractVersion, args.contractType);
+    return ethers.utils.defaultAbiCoder.encode(['bytes', 'uint256', 'uint256'], [
+        args.signature,
+        ethers.BigNumber.from(args.timestamp),
+        ethers.BigNumber.from(versionType),
+    ]);
+}
+// ---------------------------------------------------------------------------
+// The signed messages
+// ---------------------------------------------------------------------------
+const MONTH_NAMES = [
+    'January',
+    'February',
+    'March',
+    'April',
+    'May',
+    'June',
+    'July',
+    'August',
+    'September',
+    'October',
+    'November',
+    'December',
+];
+/**
+ * Format a unix timestamp as `{day} {MonthName} {yyyy}, {HH}:{mm}` in UTC.
+ * Day is non-padded; hour and minute are zero-padded to two digits (24h). A
+ * timestamp with >= 13 digits is treated as milliseconds, otherwise as seconds
+ * — the same auto-detection kasu-backend applies.
+ *
+ * Deliberately a manual formatter with English month names: no locale, no
+ * `Intl`, so the output is byte-identical across runtimes and time zones. This
+ * is not a display date. It goes inside a signed message.
+ *
+ * e.g. 1785313320000 → `"29 July 2026, 08:22"`
+ */
+function formatSignTimestampUtc(timestamp) {
+    const ms = timestamp.toString().length >= 13 ? timestamp : timestamp * 1000;
+    const date = new Date(ms);
+    const day = date.getUTCDate();
+    const month = MONTH_NAMES[date.getUTCMonth()];
+    const year = date.getUTCFullYear();
+    const hours = String(date.getUTCHours()).padStart(2, '0');
+    const minutes = String(date.getUTCMinutes()).padStart(2, '0');
+    return `${day} ${month} ${year}, ${hours}:${minutes}`;
+}
+/**
+ * The 4-line human-readable message a lender signs to generate their loan
+ * agreement for review — `POST /contract/generate`.
+ *
+ * ⚠️ BYTE-EXACT PROTOCOL STRING. kasu-backend rebuilds this string from the
+ * request body and verifies the signature against it, so the wording,
+ * ordering, separators, line breaks and date format are all part of the wire
+ * contract. The separator between the line-2 fields is a MIDDLE DOT U+00B7
+ * (·) with a single space on each side; the four lines are joined with `\n`.
+ *
+ * The backend takes this format only when all four display fields are present
+ * and non-empty, and it cross-checks `amountLabel`'s leading number against
+ * the `depositAmount` it was sent (thousands separators stripped) — a message
+ * that states an amount other than the one being executed is refused.
+ */
+function buildLoanAgreementSignMessage(p) {
+    return [
+        'Generate my Loan Agreement for review:',
+        `${p.strategyName} · ${p.region} · ${p.optionName} · ${p.amountLabel}.`,
+        `Request made ${formatSignTimestampUtc(p.timestamp)} UTC.`,
+        'This request does not commit me to lend.',
+    ].join('\n');
+}
+/**
+ * The legacy `/contract/generate` and `/contract/resolve` message.
+ *
+ * ⚠️ BYTE-EXACT PROTOCOL STRING. kasu-backend rebuilds it as
+ * `` `I request contract content for ${address} at ${timestamp}.` `` from the
+ * `address` and `timestamp` fields of the request body — so the string signed
+ * and the body sent must agree exactly, INCLUDING the address casing. This
+ * builder lowercases, and the request body must carry the same lowercased
+ * address; that is what both apps signing this format do today.
+ *
+ * The backend takes this path whenever the four human-readable display fields
+ * are absent, and documents it as permanent until the legacy app is
+ * decommissioned. `/contract/resolve` has no other format — every consumer
+ * signs this one to retrieve an existing agreement.
+ *
+ * @param timestampMs ms-epoch, and the same value sent as the body's
+ *   `timestamp`.
+ */
+function buildLegacyContractRequestMessage(address, timestampMs) {
+    return `I request contract content for ${address.toLowerCase()} at ${timestampMs}.`;
+}
+/**
+ * The `POST /contract/fullname` message.
+ *
+ * ⚠️ BYTE-EXACT PROTOCOL STRING, on the same terms as
+ * `buildLegacyContractRequestMessage`: kasu-backend rebuilds
+ * `` `I request my full name for ${address} at ${timestamp}.` `` from the
+ * request body and verifies the signature against it, so the body must carry
+ * the same lowercased address this builder signs.
+ *
+ * @param timestampMs ms-epoch, and the same value sent as the body's
+ *   `timestamp`.
+ */
+function buildFullNameRequestMessage(address, timestampMs) {
+    return `I request my full name for ${address.toLowerCase()} at ${timestampMs}.`;
+}
+
+/**
+ * Cycles and the clearing window — the protocol's weekly clock, as numbers.
+ *
+ * Lifted verbatim from kasu-ui's `features/portfolio/lib/settlement-window.ts`
+ * and `features/lending/lib/cycle-dates.ts`. The two formatters that live
+ * beside `deriveCycleDates` there (`formatCycleDate`, `formatCycleCloseUtc`)
+ * print words and stay in the applications; everything here is unix seconds in
+ * and unix seconds out.
+ *
+ * The clearing window is the fixed 48 hours immediately preceding an epoch
+ * end. Inside it, pending requests are being processed and cannot be modified,
+ * and the countdown runs to the epoch end. Outside it, the countdown runs to
+ * the next clearing-window start.
+ *
+ * The epoch end comes straight from the chain (`nextEpochStartTimestamp`, i.e.
+ * the SDK's `getNextEpochDate`) — the same value the protocol's own
+ * `getNextClearingPeriodDate` derives from — so the window always lines up
+ * with the real weekly schedule (Tue 06:00 → Thu 06:00 UTC on Base) instead of
+ * a projected subgraph timestamp that can drift off the grid.
+ */
+/**
+ * Clearing-window length — a fixed 48h protocol constant. Exported so every
+ * consumer derives the window from the same number this module runs on.
+ */
+const CLEARING_WINDOW_SECONDS = 48 * 60 * 60;
+/**
+ * Weekly cadence — the epoch schedule is fixed weekly (Tue → Thu UTC on Base).
+ * Used only to roll a cycle forward when a request lands inside a window that
+ * has already closed.
+ */
+const WEEK_SECONDS = 7 * 24 * 60 * 60;
+/**
+ * Which phase of the weekly cycle `nowSeconds` falls in, and how long is left
+ * of it.
+ *
+ * `'unknown'` when no epoch boundary has been loaded yet, or when the one on
+ * hand is stale (it has already elapsed — the on-chain value refetches to the
+ * next boundary shortly after rollover). A caller must render its "no cycle
+ * loaded" state there, never a zeroed countdown.
+ */
+function computeSettlementWindow({ nowSeconds, nextEpochStart, clearingWindowSeconds = CLEARING_WINDOW_SECONDS, }) {
+    // No epoch boundary loaded yet, or a stale one that already elapsed.
+    if (nextEpochStart <= 0 || nextEpochStart <= nowSeconds) {
+        return { phase: 'unknown' };
+    }
+    const clearingStart = nextEpochStart - clearingWindowSeconds;
+    if (nowSeconds < clearingStart) {
+        return {
+            phase: 'awaiting',
+            secondsUntilClearing: clearingStart - nowSeconds,
+            nextClearingStart: clearingStart,
+        };
+    }
+    // nowSeconds is in [clearingStart, nextEpochStart) — inside the window.
+    return {
+        phase: 'clearing',
+        secondsUntilEpochEnd: nextEpochStart - nowSeconds,
+        epochEnd: nextEpochStart,
+    };
+}
+/**
+ * The next cycle boundary strictly after `nowSeconds`, in unix seconds — the
+ * cycle close (`nextEpochStart − 48h`) while the window is still open, the
+ * epoch end once we are inside it.
+ *
+ * `undefined` when there is no boundary left to wait for: no epoch boundary
+ * loaded, or a cached one that has already elapsed — the same staleness rule
+ * `computeSettlementWindow` applies before it reports `'unknown'`.
+ *
+ * Split out of the state machine because some consumers need the INSTANT
+ * rather than the phase: one to flush the cycle-dependent caches when the
+ * clock crosses it, one to move a pre-commit screen's snapshot clock at the
+ * same moment.
+ */
+function nextCycleBoundary(nextEpochStart, nowSeconds, clearingWindowSeconds = CLEARING_WINDOW_SECONDS) {
+    if (!nextEpochStart || nextEpochStart <= 0)
+        return undefined;
+    const clearingStart = nextEpochStart - clearingWindowSeconds;
+    if (nowSeconds < clearingStart)
+        return clearingStart;
+    if (nowSeconds < nextEpochStart)
+        return nextEpochStart;
+    return undefined;
+}
+/**
+ * The cycle-close and outcome dates for a request submitted `now`.
+ *
+ * - The cycle "closes" (stops accepting requests, starts processing) at the
+ *   start of the 48h clearing window, i.e. 48h before the epoch end.
+ * - Processing takes up to 48h, so the outcome is confirmed by the epoch end
+ *   (close + 48h).
+ *
+ * Returns `null` when the epoch boundary is not available or is stale — a
+ * caller then omits the dates entirely (omit, don't stub).
+ *
+ * The common case is a request submitted OUTSIDE the clearing window: the
+ * close is `nextEpochStart − 48h` and the outcome is `nextEpochStart`. When
+ * the request lands INSIDE the current clearing window (that close is already
+ * in the past), it queues for the NEXT weekly cycle, so the close is advanced
+ * by whole weeks until it is in the future.
+ */
+function deriveCycleDates(nextEpochStart, nowSeconds) {
+    // No boundary loaded, or a stale one that already elapsed — the same
+    // staleness rule as `computeSettlementWindow`.
+    if (!nextEpochStart || nextEpochStart <= nowSeconds)
+        return null;
+    let close = nextEpochStart - CLEARING_WINDOW_SECONDS;
+    let outcome = nextEpochStart;
+    // Inside the current clearing window the close already passed; a request
+    // now is queued for the next weekly cycle.
+    while (close <= nowSeconds) {
+        close += WEEK_SECONDS;
+        outcome += WEEK_SECONDS;
+    }
+    return { close, outcome };
+}
+
 // Business rename (2026-07): Apxium strategies market their top retail tranche
 // as "Upper Mezzanine" — the true senior position is held by the institutional
 // lender (Rixon Capital), so retail lenders are never actually senior in the
@@ -25279,4 +25977,60 @@ function getTrancheDisplayName(trancheName, pool) {
         : trancheName;
 }
 
-export { APXIUM, CHAIN_CONFIGS, DepositsFacade, EPOCHS_IN_YEAR, INVOICEMATE, Kasu, KasuSdk, MAX_LENDING_AMOUNT_FALLBACK, MIN_LENDING_AMOUNT_FALLBACK, MIN_TRANCHE_CAPACITY, PortfolioFacade, RIXON_CAPITAL, SdkConfig, StrategiesFacade, UPPER_MEZZANINE, apyToEpochRate, ceilToCents, compareTrancheSeniority, derivePoolStatus, epochRateToApy, fetchUnusedPoolIds, floorToCents, getCreditOriginator, getInstitutionalLender, getTrancheDisplayName, isBelowMinimumCapacity, maxNetRateCeiling, netEffectiveApy, netTrancheApyBounds, parseTrancheBound, pickDefaultTrancheId, pickHighestYieldTranche, poolAllTranchesFull, poolMaxApy, resolveBoundShortcuts, resolveDepositBounds, selectVisiblePools, trancheApyBounds, trancheHasCapacity, trancheRiskRank };
+/**
+ * Wallet and RPC error predicates — pure functions over `unknown`.
+ *
+ * Every consumer has to tell three things apart when a write fails: the lender
+ * changed their mind, the call would revert, and everything else. The first
+ * two must never be reported as a failure the lender should retry or contact
+ * support about, and each wallet spells them differently, so the shapes are
+ * enumerated once here.
+ *
+ * Lifted from kasu-ui's `src/lib/web3/is-user-rejected.ts` and kasu-mobile's
+ * `src/features/lending/lib/errors.ts`.
+ */
+/**
+ * Did the lender reject the request in their wallet?
+ *
+ * Providers surface a rejection in different shapes:
+ *   - MetaMask and most EIP-1193 wallets: `code: 4001`
+ *   - WalletConnect and some Privy paths: `Error('User rejected the request')`
+ *   - ethers v5 wraps it as `ACTION_REJECTED`
+ *   - Coinbase Wallet sometimes: `code: 'ACTION_REJECTED'` as a string
+ *
+ * This is kasu-ui's implementation verbatim. kasu-mobile's copy additionally
+ * reads a nested `error.code` / `error.message`, an ethers `reason`, and the
+ * words "request rejected" / "declined"; a consumer that needs those shapes
+ * should keep its own check on top rather than assume they are covered here.
+ */
+function isUserRejected(err) {
+    if (!err)
+        return false;
+    if (typeof err === 'object') {
+        const code = err.code;
+        if (code === 4001 || code === 'ACTION_REJECTED')
+            return true;
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    const lower = msg.toLowerCase();
+    return (lower.includes('user rejected') ||
+        lower.includes('user denied') ||
+        lower.includes('rejected the request') ||
+        lower.includes('action_rejected'));
+}
+/**
+ * Did the wallet or RPC signal that the on-chain call would revert?
+ *
+ * ethers v5 raises `UNPREDICTABLE_GAS_LIMIT` when gas estimation reverts —
+ * most often an underlying `transferFrom` failing on an insufficient balance
+ * or allowance. Distinct from a rejection: nothing was refused by the lender,
+ * the transaction simply cannot succeed as composed, so the caller should
+ * re-check its preconditions rather than invite a retry.
+ */
+function isUnpredictableGas(err) {
+    if (!err || typeof err !== 'object')
+        return false;
+    return err.code === 'UNPREDICTABLE_GAS_LIMIT';
+}
+
+export { APXIUM, AU_ALPHA3, AU_MIN_CUMULATIVE_BY_STABLE, CHAIN_CONFIGS, CLEARING_WINDOW_SECONDS, DepositsFacade, EPOCHS_IN_YEAR, INVOICEMATE, Kasu, KasuSdk, MAX_LENDING_AMOUNT_FALLBACK, MIN_LENDING_AMOUNT_FALLBACK, MIN_TRANCHE_CAPACITY, NO_DIRECTUS_URL_MESSAGE, PortfolioFacade, RIXON_CAPITAL, SdkConfig, StrategiesFacade, UPPER_MEZZANINE, apyToEpochRate, asContractType, auMinimumRemaining, auThresholdFor, buildContractVersionType, buildFullNameRequestMessage, buildLegacyContractRequestMessage, buildLoanAgreementSignMessage, ceilToCents, compareTrancheSeniority, computeSettlementWindow, countSubmissions, deriveCycleDates, derivePoolStatus, deriveRequestState, encodeDepositData, epochRateToApy, fetchUnusedPoolIds, firstSubmissionTimestamp, floorToCents, formatSignTimestampUtc, getCreditOriginator, getInstitutionalLender, getTrancheDisplayName, isAuMinimumExempt, isAustralianKyc, isBelowMinimumCapacity, isCycleClosed, isUnpredictableGas, isUserRejected, maxNetRateCeiling, netEffectiveApy, netTrancheApyBounds, nextCycleBoundary, parseFormattedMessage, parseMinorUnits, parseTrancheBound, pickDefaultTrancheId, pickHighestYieldTranche, poolAllTranchesFull, poolMaxApy, resolveBoundShortcuts, resolveDepositBounds, selectVisiblePools, submissionEvents, trancheApyBounds, trancheHasCapacity, trancheRiskRank };