@kasufinance/kasu-sdk 2.5.0 → 2.7.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}`;
@@ -16176,7 +16205,6 @@ class DataService {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             const poolDelegateProfileAndHistoryDirectus = (yield this._directus.request(bs('PoolDelegateProfileAndHistory', {
-                // @ts-ignore Directus' deep-fields typing is fragile across versions
                 fields: ['*', { otherPools: ['*'] }],
             })));
             const [poolNames, directusPoolNames] = yield Promise.all([
@@ -17136,9 +17164,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 +17282,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 +24324,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,
@@ -24313,6 +24350,19 @@ const CHAIN_CONFIGS = {
     },
 };
 
+/**
+ * The refusal every write path shares when the instance holds a Provider
+ * rather than a Signer.
+ *
+ * One constant, because the message's job is to name the fix — `kasu.connect`
+ * — and three near-identical wordings across the facades would be three
+ * different pieces of advice for one problem. ethers' own
+ * "sending a transaction requires a signer" arrives several frames deeper,
+ * after the params have been encoded, and says nothing about how to get a
+ * signer onto THIS object.
+ */
+const READ_ONLY_MESSAGE = 'Kasu: this instance is read-only; call kasu.connect(signer) first';
+
 /**
  * High-level facade for deposit and withdrawal operations.
  *
@@ -24341,7 +24391,7 @@ class DepositsFacade {
      */
     assertWritable() {
         if (this._isReadOnly) {
-            throw new Error('Kasu: this instance is read-only; call kasu.connect(signer) first');
+            throw new Error(READ_ONLY_MESSAGE);
         }
     }
     /**
@@ -24414,6 +24464,1024 @@ class DepositsFacade {
     }
 }
 
+/**
+ * The tiny observable-state kernel both flows are built on.
+ *
+ * Deliberately not a framework store: no React, no signals, no dependency.
+ * A flow is a long asynchronous run that has to publish every transition to
+ * whatever is rendering it, and has to be able to abandon a run that the
+ * consumer walked away from. That is the whole requirement, and it is 60 lines.
+ *
+ * The `generation` counter is the abandonment mechanism. `reset()` bumps it;
+ * an in-flight run captured the previous value, so every later `patch` it
+ * attempts is dropped and every `isCurrent` checkpoint tells it to stop. It is
+ * what makes `reset()` safe to call mid-flight — the run cannot resurrect a
+ * dead state or, worse, drive the UI back into a phase the consumer has left.
+ */
+class FlowStore {
+    constructor(_initial) {
+        this._initial = _initial;
+        this._generation = 0;
+        this._listeners = new Set();
+        this._state = _initial;
+    }
+    get state() {
+        return this._state;
+    }
+    /** The run token an in-flight pipeline captures at `start()`. */
+    get generation() {
+        return this._generation;
+    }
+    /** False once `reset()` (or a later `start()`) has superseded `token`. */
+    isCurrent(token) {
+        return this._generation === token;
+    }
+    /**
+     * Subscribe to every transition. Returns the unsubscribe function; calling
+     * it twice is harmless.
+     *
+     * Listeners are NOT called on subscribe — read `state` for the current
+     * value. A listener that throws is not allowed to break the pipeline or
+     * starve the listeners registered after it, so throws are swallowed.
+     */
+    subscribe(listener) {
+        this._listeners.add(listener);
+        return () => {
+            this._listeners.delete(listener);
+        };
+    }
+    /**
+     * Merge `next` into the state and notify, unless `token` names a
+     * superseded run.
+     */
+    patch(next, token) {
+        if (token !== undefined && !this.isCurrent(token))
+            return;
+        this._state = Object.assign(Object.assign({}, this._state), next);
+        for (const listener of [...this._listeners]) {
+            try {
+                listener(this._state);
+            }
+            catch (_a) {
+                // A consumer's rendering fault is its own problem; the pipeline
+                // owns real money and keeps going.
+            }
+        }
+    }
+    /**
+     * Back to the initial state, abandoning any in-flight run.
+     *
+     * Subscribers are kept: the consumer that was watching the last run is the
+     * one that will watch the next.
+     */
+    reset() {
+        this._generation += 1;
+        this.patch(this._initial);
+    }
+    /** Claim the next run token. Any earlier run is abandoned. */
+    beginRun() {
+        this._generation += 1;
+        return this._generation;
+    }
+}
+
+/**
+ * The run lifecycle both flows share: one run at a time, every transition
+ * published, and a `reset()` that is safe to call in the middle of one.
+ *
+ * `DepositFlow` and `WithdrawFlow` each carried their own copy of this — the
+ * re-entrancy guard, the `try/finally` around the run, `state`, `isRunning`,
+ * `subscribe`, `reset`. Two copies of a guard is two places for a guard to be
+ * wrong, on the money path, which is the same reason the pipelines themselves
+ * moved out of the applications.
+ *
+ * ## The guard and the run token are separate, and both matter
+ *
+ * `_runToken` is the re-entrancy guard: claimed synchronously, before the
+ * first `await`, so a double tap cannot launch two pipelines. The store's
+ * `generation` is the abandonment mechanism: an in-flight run holds the value
+ * it claimed, and every `patch` and `isCurrent` checkpoint it makes after
+ * `reset()` is dropped.
+ *
+ * `reset()` releases the guard IMMEDIATELY rather than waiting for the
+ * abandoned run to notice. It has to: a run parked on a wallet prompt that
+ * never answers is a promise that may never settle, and a consumer that has
+ * left that screen must be able to start a new run in the same tick. The
+ * abandoned run's `finally` therefore releases the guard only if it still
+ * holds it — by then a NEW run may own it, and clearing it there would let a
+ * third run start alongside the second.
+ */
+class Flow {
+    constructor(initial) {
+        /**
+         * The token of the run currently holding the guard, or `null` when none
+         * does. Not a boolean: releasing the guard has to be attributable to the
+         * run that claimed it.
+         */
+        this._runToken = null;
+        this._store = new FlowStore(initial);
+    }
+    /** The current state. Every transition is also published to `subscribe`. */
+    get state() {
+        return this._store.state;
+    }
+    /** True while a run is in flight, including while parked. */
+    get isRunning() {
+        return this._runToken !== null;
+    }
+    /**
+     * Observe every transition. Returns the unsubscribe function.
+     *
+     * The listener is not called on subscribe; read `state` for the value it
+     * starts from.
+     */
+    subscribe(listener) {
+        return this._store.subscribe(listener);
+    }
+    /**
+     * Run the pipeline. Resolves when it reaches a terminal phase — it does
+     * not reject, because every outcome a consumer can act on is in `state`.
+     *
+     * A second call while one is in flight is a no-op: one submission per
+     * intent, however many times the button is pressed.
+     */
+    start(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._runToken !== null)
+                return;
+            this._store.reset();
+            const token = this._store.beginRun();
+            this._runToken = token;
+            try {
+                yield this._run(input, token);
+            }
+            finally {
+                if (this._runToken === token)
+                    this._runToken = null;
+            }
+        });
+    }
+    /**
+     * Back to `idle`, abandoning any run in flight: its remaining transitions
+     * are dropped, whatever it is parked on is unparked, and the guard is
+     * released at once so `start()` is accepted in the SAME tick. Subscribers
+     * are kept — the consumer watching the last run is the one watching the
+     * next.
+     */
+    reset() {
+        this._runToken = null;
+        // Bump the generation BEFORE unparking, so the abandoned run's next
+        // checkpoint already reads as superseded.
+        this._store.reset();
+        this._onAbandon();
+    }
+    /**
+     * Hook for a flow that parks: unpark it. Called by `reset()` after the
+     * generation has been bumped, so anything the abandoned run does with the
+     * result is dropped.
+     */
+    _onAbandon() {
+        // A flow with nothing parked has nothing to unpark.
+    }
+}
+
+/** 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}.`;
+}
+
+/**
+ * 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` — and now the UNION of the two, so
+ * neither app has to keep a wrapper on top of this one.
+ */
+/**
+ * Did the lender reject the request in their wallet?
+ *
+ * Providers surface a rejection in different shapes, and the union of them is
+ * the point of this function existing once:
+ *   - MetaMask and most EIP-1193 wallets: `code: 4001`
+ *   - Coinbase Wallet and ethers v5: `code: 'ACTION_REJECTED'`
+ *   - viem: a `UserRejectedRequestError` name
+ *   - WalletConnect and some Privy paths: `Error('User rejected the request')`
+ *   - a provider error WRAPPED by another layer, carrying the real code and
+ *     message on a nested `error` — the shape Privy's embedded wallet
+ *     surfaces on Expo, where the outer object says nothing useful
+ *   - ethers' own `reason` field, which is often the only place the text lands
+ *   - a PLAIN OBJECT carrying `message`, which `String(err)` would read as
+ *     `"[object Object]"`
+ *
+ * Previously kasu-ui's implementation verbatim, with kasu-mobile keeping its
+ * own superset on top. That is precisely the drift this layer exists to stop —
+ * a rejection kasu-mobile recognised and kasu-ui did not was reported to the
+ * same lender as a failure on one app and a cancellation on the other. The
+ * union lives here; the mobile wrapper goes.
+ *
+ * ## The text is read for a SUBJECT, not for a keyword
+ *
+ * The words alone are not the signal. "Declined" and "request rejected" are
+ * also what a rate limiter, a risk engine and a KYC decision say, and those
+ * arrive wrapped in exactly the same envelope a wallet error does — ethers'
+ * `SERVER_ERROR` around `-32603` carries the upstream body on a nested
+ * `error.message`, so `{ error: { message: 'request rejected: rate limit
+ * exceeded' } }` is an RPC refusing to serve us, not a lender refusing to
+ * sign. Reporting one as the other tells a lender they cancelled something
+ * they never saw, and DROPS the real error on the floor.
+ *
+ * So a rejection is a machine-readable wallet code, or a sentence that names
+ * the party who did it: "user rejected", "declined by the user", "cancelled by
+ * the wallet". A bare "declined" is not a rejection, whatever else is on the
+ * envelope.
+ *
+ * Within that rule, being generous is the safe direction: calling a genuine
+ * fault a cancellation costs a lender one retry, while calling a deliberate
+ * rejection a failure sends them to support to report a bug that does not
+ * exist.
+ */
+function isUserRejected(err) {
+    var _a;
+    if (!err)
+        return false;
+    if (typeof err === 'object') {
+        const e = err;
+        if (isRejectionCode(e.code))
+            return true;
+        // A wrapped provider error: the outer layer's code is its own, the
+        // inner one is the wallet's.
+        if (isRejectionCode((_a = e.error) === null || _a === void 0 ? void 0 : _a.code))
+            return true;
+    }
+    const lower = rejectionText(err).toLowerCase();
+    return USER_REJECTION_PATTERNS.some((pattern) => pattern.test(lower));
+}
+function isRejectionCode(code) {
+    return code === 4001 || code === 'ACTION_REJECTED';
+}
+/**
+ * The wordings that name the wallet or the person at it.
+ *
+ * Each one carries a SUBJECT — the identifier a wallet library uses, or the
+ * verb with the party who performed it. That is what separates a lender
+ * pressing Reject from a server declining to answer, and it is why none of
+ * these is a bare "declined" or "rejected".
+ */
+const USER_REJECTION_PATTERNS = [
+    // Machine-readable markers that only a wallet layer emits, arriving as
+    // text because something in between stringified the error.
+    /action_rejected/,
+    /user_rejected/,
+    /userrejectedrequest/,
+    // "the user did it", in the orders the wallets write it.
+    /user\s+(?:has\s+)?(?:rejected|denied|declined|refused|cancell?ed)/,
+    /(?:rejected|denied|declined|refused|cancell?ed)\s+by\s+(?:the\s+)?(?:user|wallet|signer|owner)/,
+    // The wallet as the subject, which is how some embedded wallets word it.
+    /(?:wallet|signer)\s+(?:rejected|denied|declined|refused)/,
+];
+/**
+ * Every place a wallet might have put the words: the message, ethers' `reason`,
+ * the error's `name` (viem puts the whole signal there), and a wrapped error's
+ * own three. Joined rather than picked, because which one carries the text
+ * depends on how many layers wrapped it.
+ *
+ * A separator is used rather than a bare space: two fields must not be able to
+ * form a phrase across the join that neither of them said.
+ */
+function rejectionText(err) {
+    var _a, _b, _c;
+    if (typeof err !== 'object' || err === null)
+        return String(err);
+    const e = err;
+    return [
+        e.message,
+        e.reason,
+        e.name,
+        (_a = e.error) === null || _a === void 0 ? void 0 : _a.message,
+        (_b = e.error) === null || _b === void 0 ? void 0 : _b.reason,
+        (_c = e.error) === null || _c === void 0 ? void 0 : _c.name,
+    ]
+        .filter((part) => typeof part === 'string')
+        .join(' | ');
+}
+/**
+ * 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';
+}
+/**
+ * The `cancelled` / `failed` split, for a WALLET call on any step of any flow.
+ *
+ * A lender who pressed Reject is not a fault. Reporting one as the other is
+ * how a support queue fills with people who did exactly what they meant to.
+ *
+ * Generic in the step so both flows share one implementation — it was
+ * duplicated byte-for-byte in each of them, which is the same drift this
+ * layer exists to stop, one level up.
+ *
+ * Only pass it an error a WALLET produced. An HTTP port's throw is always a
+ * `failed`: the lender's wallet was not involved in it, so a backend that
+ * happens to word a refusal "declined" must never be shown to them as
+ * something they did.
+ */
+function classifyWalletFailure(step, err) {
+    return isUserRejected(err)
+        ? { step, reason: 'cancelled' }
+        : { step, reason: 'failed', error: err };
+}
+
+/** Generated agreements are valid for five minutes upstream. */
+const CONTRACT_TTL_MS = 5 * 60 * 1000;
+/** What a run without a spender, from either source, fails with. */
+const NO_SPENDER_MESSAGE = 'DepositFlow: no ERC-20 spender; build the flow with kasu.flows.deposit() or pass `spender` on the input';
+const INITIAL$1 = {
+    phase: 'idle',
+    step: null,
+    stepIndex: 0,
+    stepTotal: 4,
+    approvalRequired: true,
+    contract: null,
+    failure: null,
+};
+/** 1-based badge position, with `approve` dropped when it is out of scope. */
+function stepIndexOf(step, approvalRequired) {
+    const order = approvalRequired
+        ? ['generate', 'confirm', 'approve', 'request']
+        : ['generate', 'confirm', 'request'];
+    return order.indexOf(step) + 1;
+}
+function badgeFor(step, approvalRequired) {
+    return {
+        step,
+        stepIndex: stepIndexOf(step, approvalRequired),
+        stepTotal: approvalRequired ? 4 : 3,
+    };
+}
+/**
+ * The request step has a third outcome. `UNPREDICTABLE_GAS_LIMIT` here is
+ * almost always `transferFrom` reverting on a balance that cannot cover the
+ * deposit, and it takes precedence: nothing was refused by the lender, so
+ * inviting a retry would just reproduce it.
+ */
+function classifyRequest(err) {
+    if (isUnpredictableGas(err)) {
+        return { step: 'request', reason: 'insufficient-balance', error: err };
+    }
+    return classifyWalletFailure('request', err);
+}
+// ---------------------------------------------------------------------------
+// The flow
+// ---------------------------------------------------------------------------
+class DepositFlow extends Flow {
+    constructor(_ports, opts) {
+        var _a;
+        super(INITIAL$1);
+        this._ports = _ports;
+        /**
+         * The accept handshake. The run parks on this promise; `acceptContract`,
+         * `declineContract` and `reset` each settle it with an `AcceptOutcome`.
+         * Cleared the moment it settles so a stale resolver from an abandoned run
+         * can never leak into the next one.
+         */
+        this._accept = null;
+        /**
+         * The run token that is between `acceptContract()` and the wallet
+         * settling, or `null`.
+         *
+         * A token rather than a boolean, because the flag has to belong to the RUN
+         * that set it: after `reset()` out of a wallet prompt that never answers,
+         * the abandoned run's `finally` may not arrive for minutes, and a boolean
+         * left standing refuses both Accept and Decline on every run after it.
+         * A stale token simply is not the current generation.
+         */
+        this._acceptingFor = null;
+        this._ttlMs = (_a = opts === null || opts === void 0 ? void 0 : opts.contractTtlMs) !== null && _a !== void 0 ? _a : CONTRACT_TTL_MS;
+        this._defaultSpender = opts === null || opts === void 0 ? void 0 : opts.spender;
+        // Called through the ports object, never captured off it: a consumer
+        // whose clock is a method on its own object keeps its `this`.
+        this._now = () => { var _a, _b; return (_b = (_a = _ports.now) === null || _a === void 0 ? void 0 : _a.call(_ports)) !== null && _b !== void 0 ? _b : Date.now(); };
+    }
+    /**
+     * Sign the agreement and resume the parked run. A no-op when nothing is
+     * parked, so a double tap cannot sign twice.
+     */
+    acceptContract() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bridge = this._accept;
+            const contract = this._store.state.contract;
+            if (!bridge || !contract || this._isAccepting())
+                return;
+            const token = this._store.generation;
+            this._acceptingFor = token;
+            this._store.patch(Object.assign({ phase: 'accepting-sign' }, badgeFor('confirm', this._store.state.approvalRequired)), token);
+            try {
+                const signature = yield this._ports.signMessage(contract.contractMessage);
+                bridge.settle({ kind: 'accepted', signature });
+            }
+            catch (err) {
+                // A WALLET error, and the only one this flow classifies as a
+                // possible cancellation on the confirm step.
+                bridge.settle({ kind: 'failed', error: err });
+            }
+            finally {
+                // Only if this run still holds it: a `reset()` during the prompt
+                // may have started another one, and that one's flag is its own.
+                if (this._acceptingFor === token)
+                    this._acceptingFor = null;
+            }
+        });
+    }
+    /**
+     * Back out of the agreement. The run ends on `declined` — a legitimate
+     * choice, not a failure, and `state.failure` stays null.
+     *
+     * Ignored once `acceptContract()` has opened the wallet: an agreement in
+     * the middle of being signed cannot also be refused. `reset()` is the way
+     * out of a prompt that never answers.
+     */
+    declineContract() {
+        const bridge = this._accept;
+        if (!bridge || this._isAccepting())
+            return;
+        this._accept = null;
+        bridge.settle({ kind: 'declined' });
+    }
+    /** True only while THIS generation is waiting on the acceptance signature. */
+    _isAccepting() {
+        return (this._acceptingFor !== null &&
+            this._store.isCurrent(this._acceptingFor));
+    }
+    /** `reset()`: unpark the abandoned run and drop its handshake. */
+    _onAbandon() {
+        const bridge = this._accept;
+        this._accept = null;
+        this._acceptingFor = null;
+        bridge === null || bridge === void 0 ? void 0 : bridge.settle({ kind: 'abandoned' });
+    }
+    // -----------------------------------------------------------------------
+    _run(input, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this._accept = null;
+            this._acceptingFor = null;
+            const ports = this._ports;
+            const owner = input.userAddress.toLowerCase();
+            // 0. The spender, from the input or from the chain config the facade
+            //    built this flow with. Without one there is nothing to read an
+            //    allowance against and nothing to approve — and guessing would
+            //    grant an approval to the wrong contract.
+            const spender = (_a = input.spender) !== null && _a !== void 0 ? _a : this._defaultSpender;
+            if (!spender) {
+                this._fail(token, true, {
+                    step: 'generate',
+                    reason: 'failed',
+                    error: new Error(NO_SPENDER_MESSAGE),
+                });
+                return;
+            }
+            // 1. Allowance pre-check. Decides `approvalRequired` — and therefore
+            //    the badge total — before the lender is shown a single step. Read
+            //    live, never cached: an exact-amount approval is fully consumed by
+            //    the deposit it paid for, so a stale allowance is exactly the value
+            //    that would wrongly skip the approve and revert the deposit.
+            let approvalRequired = true;
+            try {
+                const allowance = yield ports.readAllowance(owner, spender);
+                approvalRequired = allowance.lt(input.amount);
+            }
+            catch (_b) {
+                // A read failure is not a reason to skip an approval. Assume one is
+                // needed: the cost is a redundant approve, the alternative is a
+                // reverted deposit.
+                approvalRequired = true;
+            }
+            if (!this._store.isCurrent(token))
+                return;
+            // 2. Generate — sign the auth message.
+            this._store.patch(Object.assign({ approvalRequired, phase: 'generating-sign' }, badgeFor('generate', approvalRequired)), token);
+            const timestamp = this._now();
+            const signedMessage = buildAuthMessage(input, owner, timestamp);
+            let signature;
+            try {
+                signature = yield ports.signMessage(signedMessage);
+            }
+            catch (err) {
+                this._fail(token, approvalRequired, classifyWalletFailure('generate', err));
+                return;
+            }
+            if (!this._store.isCurrent(token))
+                return;
+            // 3. Generate — POST the request.
+            this._store.patch(Object.assign({ phase: 'generating-fetch' }, badgeFor('generate', approvalRequired)), token);
+            let contract;
+            try {
+                contract = yield ports.generateContract(Object.assign({ address: owner, signature,
+                    timestamp,
+                    signedMessage, poolId: input.poolId, trancheId: input.trancheId, fixedTermConfigId: input.fixedTermConfigId, depositAmount: input.depositAmount }, displayFieldsOf(input.contractMessage)));
+            }
+            catch (err) {
+                // Never a wallet rejection: this step is an HTTP call, and the
+                // lender's wallet was not involved in it. A backend that happened
+                // to echo the words "user rejected" must not be reported to them as
+                // something they did.
+                this._fail(token, approvalRequired, {
+                    step: 'generate',
+                    reason: 'failed',
+                    error: err,
+                });
+                return;
+            }
+            if (!this._store.isCurrent(token))
+                return;
+            // 4. Park on the agreement until the consumer accepts or declines.
+            const outcome = yield new Promise((resolve) => {
+                this._accept = { settle: resolve };
+                this._store.patch(Object.assign({ phase: 'awaiting-accept', contract }, badgeFor('confirm', approvalRequired)), token);
+            });
+            this._accept = null;
+            // An abandoned run lands here too — `reset()` unparks it. The token
+            // check is what tells the two apart.
+            if (!this._store.isCurrent(token))
+                return;
+            if (outcome.kind === 'declined') {
+                this._store.patch(Object.assign({ phase: 'declined' }, badgeFor('confirm', approvalRequired)), token);
+                return;
+            }
+            if (outcome.kind !== 'accepted') {
+                if (outcome.kind === 'failed') {
+                    this._fail(token, approvalRequired, classifyWalletFailure('confirm', outcome.error));
+                }
+                return;
+            }
+            // 5. TTL guard. Checked here because this is where the idling happens:
+            //    the lender has just spent as long as they wanted reading. An
+            //    expired agreement is refused rather than broadcast — the on-chain
+            //    call would revert, after a wallet prompt and a gas estimate, with
+            //    nothing on screen explaining why.
+            if (this._now() > contract.timestamp + this._ttlMs) {
+                this._fail(token, approvalRequired, {
+                    step: 'request',
+                    reason: 'contract-expired',
+                });
+                return;
+            }
+            const depositData = encodeDepositData({
+                signature: outcome.signature,
+                timestamp: contract.timestamp,
+                contractVersion: contract.contractVersion,
+                contractType: asContractType(contract.contractType),
+            });
+            // 6. Approve — the EXACT amount, never `MaxUint256`. House rule: an
+            //    unlimited allowance outlives the deposit it was granted for, and a
+            //    later exploit of the spender would drain a wallet that has long
+            //    since stopped lending.
+            if (approvalRequired) {
+                this._store.patch(Object.assign({ phase: 'approve' }, badgeFor('approve', approvalRequired)), token);
+                try {
+                    const tx = yield ports.approve(spender, input.amount);
+                    yield tx.wait();
+                }
+                catch (err) {
+                    this._fail(token, approvalRequired, classifyWalletFailure('approve', err));
+                    return;
+                }
+                if (!this._store.isCurrent(token))
+                    return;
+            }
+            // 7. Request — KYC signature, then the deposit and its receipt.
+            this._store.patch(Object.assign({ phase: 'request-sign' }, badgeFor('request', approvalRequired)), token);
+            // The two KYC ports reach the consumer's own backend, so they fail the
+            // way the generate step does: `failed`, with the error kept. Running
+            // them through the rejection classifier would let a backend wording —
+            // "Declined", "request rejected" — end a run as "you cancelled in your
+            // wallet", with the real error discarded and nothing to report.
+            let kyc;
+            try {
+                const kycParams = yield ports.buildKycParams(owner);
+                kyc = yield ports.getKycSignature(kycParams);
+            }
+            catch (err) {
+                this._fail(token, approvalRequired, {
+                    step: 'request',
+                    reason: 'failed',
+                    error: err,
+                });
+                return;
+            }
+            if (!this._store.isCurrent(token))
+                return;
+            try {
+                const tx = yield ports.deposit({
+                    poolId: input.poolId,
+                    trancheId: input.trancheId,
+                    amount: input.amount,
+                    kycSignature: {
+                        blockExpiration: kyc.blockExpiration,
+                        signature: kyc.signature,
+                    },
+                    depositData,
+                    fixedTermConfigId: input.fixedTermConfigId,
+                });
+                this._store.patch(Object.assign({ phase: 'request-confirm' }, badgeFor('request', approvalRequired)), token);
+                yield tx.wait();
+            }
+            catch (err) {
+                this._fail(token, approvalRequired, classifyRequest(err));
+                return;
+            }
+            if (!this._store.isCurrent(token))
+                return;
+            this._store.patch(Object.assign({ phase: 'success' }, badgeFor('request', approvalRequired)), token);
+        });
+    }
+    _fail(token, approvalRequired, failure) {
+        this._store.patch(Object.assign({ phase: 'error', failure }, badgeFor(failure.step, approvalRequired)), token);
+    }
+}
+// ---------------------------------------------------------------------------
+// Message building
+// ---------------------------------------------------------------------------
+/**
+ * The auth message, in whichever format the consumer asked for. Both builders
+ * are the byte-exact protocol strings from `domain/loan-contract` — the string
+ * signed here and the body posted from `_run` state the SAME timestamp and the
+ * SAME lowercased address, because kasu-backend rebuilds one from the other.
+ */
+function buildAuthMessage(input, owner, timestamp) {
+    if (input.contractMessage.format === 'legacy') {
+        return buildLegacyContractRequestMessage(owner, timestamp);
+    }
+    const { strategyName, region, optionName, amountLabel } = input.contractMessage;
+    return buildLoanAgreementSignMessage({
+        strategyName,
+        region,
+        optionName,
+        amountLabel,
+        timestamp,
+    });
+}
+/**
+ * The four display fields, present only on the new format. The backend picks
+ * its verification path on their presence: all four → the human-readable
+ * format, any missing → the legacy string.
+ */
+function displayFieldsOf(message) {
+    if (message.format === 'legacy')
+        return {};
+    return {
+        strategyName: message.strategyName,
+        region: message.region,
+        optionName: message.optionName,
+        amountLabel: message.amountLabel,
+    };
+}
+
+const INITIAL = {
+    phase: 'idle',
+    step: null,
+    isMax: false,
+    failure: null,
+};
+/** What a KYC pre-check with no `buildKycParams` to call fails with. */
+const NO_KYC_PARAMS_MESSAGE = 'WithdrawFlow: getKycSignature was supplied without buildKycParams; build the flow with kasu.flows.withdraw() or pass both';
+// ---------------------------------------------------------------------------
+// The flow
+// ---------------------------------------------------------------------------
+class WithdrawFlow extends Flow {
+    constructor(_ports) {
+        super(INITIAL);
+        this._ports = _ports;
+    }
+    _run(input, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ports = this._ports;
+            const isMax = input.amount === 'max';
+            // 1. The optional KYC pre-check: build the params, exchange them for a
+            //    signature. Both ports reach the application's own backend, so a
+            //    throw here is ALWAYS `failed` — running it through the wallet
+            //    rejection classifier would let a backend's "Declined" be reported
+            //    to a lender as something they did, with the real error dropped.
+            if (ports.getKycSignature) {
+                this._store.patch({ phase: 'checking-kyc', step: 'kyc', isMax }, token);
+                try {
+                    if (!ports.buildKycParams) {
+                        throw new Error(NO_KYC_PARAMS_MESSAGE);
+                    }
+                    const params = yield ports.buildKycParams(input.userAddress);
+                    yield ports.getKycSignature(params);
+                }
+                catch (err) {
+                    this._store.patch({
+                        phase: 'error',
+                        failure: { step: 'kyc', reason: 'failed', error: err },
+                    }, token);
+                    return;
+                }
+                if (!this._store.isCurrent(token))
+                    return;
+            }
+            // 2. The submission. This one IS a wallet call, so it keeps the
+            //    `cancelled` / `failed` split.
+            this._store.patch({ phase: 'request-sign', step: 'request', isMax }, token);
+            try {
+                const tx = input.amount === 'max'
+                    ? yield ports.withdrawMax(input.poolId, input.trancheId, input.userAddress.toLowerCase())
+                    : yield ports.withdraw({
+                        poolId: input.poolId,
+                        trancheId: input.trancheId,
+                        amount: input.amount,
+                    });
+                this._store.patch({ phase: 'request-confirm' }, token);
+                yield tx.wait();
+            }
+            catch (err) {
+                this._store.patch({
+                    phase: 'error',
+                    failure: classifyWalletFailure('request', err),
+                }, token);
+                return;
+            }
+            if (!this._store.isCurrent(token))
+                return;
+            this._store.patch({ phase: 'success' }, token);
+        });
+    }
+}
+
+/**
+ * Builds `DepositFlow` / `WithdrawFlow` instances wired to THIS Kasu instance:
+ * its chain's stable token, its `LendingPoolManager`, its signer.
+ *
+ * ```ts
+ * const flow = kasu.connect(signer).flows.deposit({
+ *   signMessage: (m) => signer.signMessage(m),
+ *   generateContract: (req) => postToMyProxy(req),
+ *   getKycSignature: (p) => postToMyBackend(p),
+ * });
+ * ```
+ *
+ * A flow built from a read-only instance constructs fine and reads fine — the
+ * write ports throw `READ_ONLY_MESSAGE` when the run reaches them, exactly as
+ * `kasu.deposits.deposit` does. Constructing is not the mistake; submitting is.
+ *
+ * It holds the `DepositsFacade` and NOTHING the facade already owns: no
+ * `UserLending`, no chain id, no signer. Two paths to one behaviour is how the
+ * KYC params a flow built came to differ from the ones `kasu.deposits`
+ * built — the same class of drift the flows themselves exist to end.
+ */
+class FlowsFacade {
+    constructor(_deposits, 
+    /**
+     * The chain's stable token, bound to whatever the Kasu instance holds.
+     * A factory rather than a contract: it is one `new Contract`, and a
+     * cached binding would outlive the config it was built from.
+     */
+    _erc20, 
+    /** The read-only flag `Kasu` already computed — never re-derived here. */
+    _isReadOnly, 
+    /**
+     * The ERC-20 spender every deposit run approves: this chain's
+     * `LendingPoolManager`, which is the only contract the default deposit
+     * port calls. Passed to the flow so a consumer never has to hand-wire
+     * an address whose only wrong value grants an approval to the wrong
+     * contract.
+     */
+    _spender) {
+        this._deposits = _deposits;
+        this._erc20 = _erc20;
+        this._isReadOnly = _isReadOnly;
+        this._spender = _spender;
+    }
+    /**
+     * A deposit pipeline. `readAllowance`, `approve`, `deposit` and
+     * `buildKycParams` default to the SDK's own implementations; pass any of
+     * them to override (kasu-ui approves through its sponsored-gas path, for
+     * one).
+     *
+     * Each default is applied per key with `??`, not by spreading `ports` over
+     * them: `{ ...defaults, ...ports }` lets an EXPLICITLY undefined value
+     * delete the default it was meant to keep, and
+     * `approve: sponsoredGas ? sponsoredApprove : undefined` is exactly how a
+     * consumer writes a conditional override.
+     */
+    deposit(ports, opts) {
+        var _a, _b, _c, _d, _e;
+        return new DepositFlow({
+            signMessage: ports.signMessage,
+            generateContract: ports.generateContract,
+            getKycSignature: ports.getKycSignature,
+            buildKycParams: (_a = ports.buildKycParams) !== null && _a !== void 0 ? _a : ((userAddress) => this._deposits.buildKycParams(userAddress)),
+            readAllowance: (_b = ports.readAllowance) !== null && _b !== void 0 ? _b : ((owner, spender) => this._erc20().allowance(owner, spender)),
+            approve: (_c = ports.approve) !== null && _c !== void 0 ? _c : ((spender, amount) => __awaiter(this, void 0, void 0, function* () {
+                this._assertWritable();
+                // The EXACT amount the flow asked for. Nothing here
+                // rounds it up, and nothing here substitutes
+                // MaxUint256.
+                return yield this._erc20().approve(spender, amount);
+            })),
+            deposit: (_d = ports.deposit) !== null && _d !== void 0 ? _d : ((params) => this._deposits.deposit(params)),
+            now: ports.now,
+        }, {
+            contractTtlMs: opts === null || opts === void 0 ? void 0 : opts.contractTtlMs,
+            // Per key here too, for the same reason the ports are: an
+            // explicit `spender: undefined` must not delete the default.
+            spender: (_e = opts === null || opts === void 0 ? void 0 : opts.spender) !== null && _e !== void 0 ? _e : this._spender,
+        });
+    }
+    /**
+     * A withdrawal pipeline. Both write ports and `buildKycParams` default to
+     * this instance; supplying `getKycSignature` turns the KYC pre-check on.
+     * Defaults are applied per key, for the reason `deposit()` gives.
+     */
+    withdraw(ports = {}) {
+        var _a, _b, _c;
+        return new WithdrawFlow({
+            buildKycParams: (_a = ports.buildKycParams) !== null && _a !== void 0 ? _a : ((userAddress) => this._deposits.buildKycParams(userAddress)),
+            getKycSignature: ports.getKycSignature,
+            withdraw: (_b = ports.withdraw) !== null && _b !== void 0 ? _b : ((params) => this._deposits.withdraw({
+                poolId: params.poolId,
+                trancheId: params.trancheId,
+                amount: params.amount,
+            })),
+            withdrawMax: (_c = ports.withdrawMax) !== null && _c !== void 0 ? _c : ((poolId, trancheId, userAddress) => this._deposits.withdrawMax(poolId, trancheId, userAddress)),
+        });
+    }
+    _assertWritable() {
+        if (this._isReadOnly) {
+            throw new Error(READ_ONLY_MESSAGE);
+        }
+    }
+}
+
 /**
  * Minimum remaining capacity (in stable-asset units) for a tranche to be
  * selectable. Mirrors `MIN_CAPACITY = toBigNumber('1')` in kasu-fe-next's
@@ -24833,6 +25901,230 @@ 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);
+}
+/**
+ * The LATEST event timestamp, or `fallback` when the timeline is empty — or
+ * when every event predates it, because `fallback` seeds the reduction. That
+ * seeding is deliberate and is kasu-ui's behaviour: `request.timestamp` is a
+ * fact about the request, and an event indexed with an earlier clock must not
+ * make the row look older than the request itself.
+ */
+function lastEventTimestamp(events, fallback) {
+    return events.reduce((max, e) => (e.timestamp > max ? e.timestamp : max), fallback);
+}
+/**
+ * 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 `reallocationTargetTrancheName`, both of which are RAW here); 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,
+        rejectedAmount: rejected,
+        reallocatedOutAmount: reallocation ? num(reallocation.assetAmount) : 0,
+        reallocationTargetTrancheName: reallocation
+            ? reallocation.trancheName
+            : null,
+        lastTimestamp: lastEventTimestamp(request.events, request.timestamp),
+        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,13 +26167,36 @@ 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);
+        });
+    }
 }
 
 /**
  * High-level entry point for external integrators.
  *
- * Provides three domain facades — `strategies`, `deposits`, `portfolio` — and
- * exposes the underlying `KasuSdk` services via `.services` for power-users.
+ * Provides four domain facades — `strategies`, `deposits`, `portfolio`,
+ * `flows` — and exposes the underlying `KasuSdk` services via `.services` for
+ * power-users.
  *
  * ```ts
  * import { Kasu } from '@kasufinance/kasu-sdk';
@@ -24905,8 +26220,13 @@ class Kasu {
         this._signerOrProvider = signerOrProvider;
         this._configOverrides = configOverrides;
         this.strategies = new StrategiesFacade(sdk.DataService, sdk.UserLending);
-        this.deposits = new DepositsFacade(sdk.UserLending, chainConfig.chainId.toString(), !Signer.isSigner(signerOrProvider));
+        // Derived ONCE and handed to every facade that needs it. Each of them
+        // re-deriving `Signer.isSigner` is how two facades come to disagree
+        // about whether the same instance can write.
+        const isReadOnly = !Signer.isSigner(signerOrProvider);
+        this.deposits = new DepositsFacade(sdk.UserLending, chainConfig.chainId.toString(), isReadOnly);
         this.portfolio = new PortfolioFacade(sdk.DataService, sdk.UserLending, sdk.Portfolio);
+        this.flows = new FlowsFacade(this.deposits, () => erc20Of(chainConfig, signerOrProvider), isReadOnly, chainConfig.contracts.LendingPoolManager);
     }
     /**
      * Create a Kasu instance with built-in chain config.
@@ -25038,6 +26358,23 @@ function rpcUrlsOf(chainConfig) {
     var _a;
     return (_a = chainConfig.rpcUrls) !== null && _a !== void 0 ? _a : [];
 }
+/**
+ * The chain's stable token, bound to whatever this instance holds.
+ *
+ * Built per call rather than cached: it is one `new Contract`, and a cached
+ * binding would outlive the signer a `connect()` replaced. A config with no
+ * `stableAsset` (a hand-written entry from before 2.5.0) throws here rather
+ * than inside ethers, naming the two ports that make the flow work without
+ * one.
+ */
+function erc20Of(chainConfig, signerOrProvider) {
+    var _a;
+    const address = (_a = stableAssetOf(chainConfig)) === null || _a === void 0 ? void 0 : _a.address;
+    if (!address) {
+        throw new Error('Kasu: this chain config has no stableAsset; pass readAllowance and approve ports explicitly');
+    }
+    return IERC20MetadataAbi__factory.connect(address, signerOrProvider);
+}
 /**
  * The read-only provider used when the caller passes no `signerOrProvider`.
  *
@@ -25123,6 +26460,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 +26741,123 @@ function getInstitutionalLender(originator) {
     return originator.name === APXIUM.name ? RIXON_CAPITAL : null;
 }
 
+/**
+ * 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 +26887,4 @@ 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 };
+export { APXIUM, AU_ALPHA3, AU_MIN_CUMULATIVE_BY_STABLE, CHAIN_CONFIGS, CLEARING_WINDOW_SECONDS, CONTRACT_TTL_MS, DepositFlow, DepositsFacade, EPOCHS_IN_YEAR, Flow, FlowStore, FlowsFacade, INVOICEMATE, Kasu, KasuSdk, MAX_LENDING_AMOUNT_FALLBACK, MIN_LENDING_AMOUNT_FALLBACK, MIN_TRANCHE_CAPACITY, NO_DIRECTUS_URL_MESSAGE, NO_KYC_PARAMS_MESSAGE, NO_SPENDER_MESSAGE, PortfolioFacade, READ_ONLY_MESSAGE, RIXON_CAPITAL, SdkConfig, StrategiesFacade, UPPER_MEZZANINE, WithdrawFlow, apyToEpochRate, asContractType, auMinimumRemaining, auThresholdFor, buildContractVersionType, buildFullNameRequestMessage, buildLegacyContractRequestMessage, buildLoanAgreementSignMessage, ceilToCents, classifyWalletFailure, compareTrancheSeniority, computeSettlementWindow, countSubmissions, deriveCycleDates, derivePoolStatus, deriveRequestState, encodeDepositData, epochRateToApy, fetchUnusedPoolIds, firstSubmissionTimestamp, floorToCents, formatSignTimestampUtc, getCreditOriginator, getInstitutionalLender, getTrancheDisplayName, isAuMinimumExempt, isAustralianKyc, isBelowMinimumCapacity, isCycleClosed, isUnpredictableGas, isUserRejected, lastEventTimestamp, maxNetRateCeiling, netEffectiveApy, netTrancheApyBounds, nextCycleBoundary, parseFormattedMessage, parseMinorUnits, parseTrancheBound, pickDefaultTrancheId, pickHighestYieldTranche, poolAllTranchesFull, poolMaxApy, resolveBoundShortcuts, resolveDepositBounds, selectVisiblePools, submissionEvents, trancheApyBounds, trancheHasCapacity, trancheRiskRank };