@kasufinance/kasu-sdk 2.6.0 → 2.7.0

package/dist/bundle.cjs.js

@@ -16207,7 +16207,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([
@@ -24353,6 +24352,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.
  *
@@ -24381,7 +24393,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);
         }
     }
     /**
@@ -24409,49 +24421,1067 @@ class DepositsFacade {
         });
     }
     /**
-     * Submit a withdrawal request for a specific stable asset amount.
+     * Submit a withdrawal request for a specific stable asset amount.
+     */
+    withdraw(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertWritable();
+            return yield this._userLending.requestWithdrawalInAsset(params.poolId, params.trancheId, params.amount);
+        });
+    }
+    /**
+     * Withdraw the entire balance from a tranche.
+     */
+    withdrawMax(poolId, trancheId, userAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertWritable();
+            return yield this._userLending.requestWithdrawalMax(poolId, trancheId, userAddress);
+        });
+    }
+    /**
+     * Build KYC signature parameters for the Nexera verification flow.
+     *
+     * The integrator is responsible for sending these to their backend,
+     * which obtains the signature from Nexera's signing service.
+     */
+    buildKycParams(userAddress) {
+        return this._userLending.buildKycSignatureParams(userAddress, this._chainId);
+    }
+    /**
+     * Check whether the pool is currently in a clearing period
+     * (deposits/withdrawals are temporarily paused).
+     */
+    isClearingPending(poolId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._userLending.isClearingPending(poolId);
+        });
+    }
+    /**
+     * Get the current epoch number.
+     */
+    getCurrentEpoch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._userLending.getCurrentEpoch();
+        });
+    }
+}
+
+/**
+ * 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.ethers.utils.defaultAbiCoder.encode(['bytes', 'uint256', 'uint256'], [
+        args.signature,
+        ethers.ethers.BigNumber.from(args.timestamp),
+        ethers.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.
      */
-    withdraw(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.assertWritable();
-            return yield this._userLending.requestWithdrawalInAsset(params.poolId, params.trancheId, params.amount);
-        });
-    }
+    _erc20, 
+    /** The read-only flag `Kasu` already computed — never re-derived here. */
+    _isReadOnly, 
     /**
-     * Withdraw the entire balance from a tranche.
+     * 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.
      */
-    withdrawMax(poolId, trancheId, userAddress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.assertWritable();
-            return yield this._userLending.requestWithdrawalMax(poolId, trancheId, userAddress);
-        });
+    _spender) {
+        this._deposits = _deposits;
+        this._erc20 = _erc20;
+        this._isReadOnly = _isReadOnly;
+        this._spender = _spender;
     }
     /**
-     * Build KYC signature parameters for the Nexera verification flow.
+     * 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).
      *
-     * The integrator is responsible for sending these to their backend,
-     * which obtains the signature from Nexera's signing service.
-     */
-    buildKycParams(userAddress) {
-        return this._userLending.buildKycSignatureParams(userAddress, this._chainId);
-    }
-    /**
-     * Check whether the pool is currently in a clearing period
-     * (deposits/withdrawals are temporarily paused).
+     * 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.
      */
-    isClearingPending(poolId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._userLending.isClearingPending(poolId);
+    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,
         });
     }
     /**
-     * Get the current epoch number.
+     * 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.
      */
-    getCurrentEpoch() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._userLending.getCurrentEpoch();
+    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);
+        }
+    }
 }
 
 /**
@@ -24910,6 +25940,16 @@ function firstSubmissionTimestamp(events, fallback) {
         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.
@@ -24993,10 +26033,10 @@ const numOrNull = (str) => {
  * 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 —
+ * 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.
@@ -25031,6 +26071,12 @@ function deriveRequestState(request) {
         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.
@@ -25150,8 +26196,9 @@ class PortfolioFacade {
 /**
  * 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';
@@ -25175,8 +26222,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(), !ethers.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 = !ethers.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.
@@ -25308,6 +26360,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`.
  *
@@ -25674,165 +26743,6 @@ 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.ethers.utils.defaultAbiCoder.encode(['bytes', 'uint256', 'uint256'], [
-        args.signature,
-        ethers.ethers.BigNumber.from(args.timestamp),
-        ethers.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.
  *
@@ -25979,69 +26889,18 @@ function getTrancheDisplayName(trancheName, pool) {
         : trancheName;
 }
 
-/**
- * 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';
-}
-
 exports.APXIUM = APXIUM;
 exports.AU_ALPHA3 = AU_ALPHA3;
 exports.AU_MIN_CUMULATIVE_BY_STABLE = AU_MIN_CUMULATIVE_BY_STABLE;
 exports.CHAIN_CONFIGS = CHAIN_CONFIGS;
 exports.CLEARING_WINDOW_SECONDS = CLEARING_WINDOW_SECONDS;
+exports.CONTRACT_TTL_MS = CONTRACT_TTL_MS;
+exports.DepositFlow = DepositFlow;
 exports.DepositsFacade = DepositsFacade;
 exports.EPOCHS_IN_YEAR = EPOCHS_IN_YEAR;
+exports.Flow = Flow;
+exports.FlowStore = FlowStore;
+exports.FlowsFacade = FlowsFacade;
 exports.INVOICEMATE = INVOICEMATE;
 exports.Kasu = Kasu;
 exports.KasuSdk = KasuSdk;
@@ -26049,11 +26908,15 @@ exports.MAX_LENDING_AMOUNT_FALLBACK = MAX_LENDING_AMOUNT_FALLBACK;
 exports.MIN_LENDING_AMOUNT_FALLBACK = MIN_LENDING_AMOUNT_FALLBACK;
 exports.MIN_TRANCHE_CAPACITY = MIN_TRANCHE_CAPACITY;
 exports.NO_DIRECTUS_URL_MESSAGE = NO_DIRECTUS_URL_MESSAGE;
+exports.NO_KYC_PARAMS_MESSAGE = NO_KYC_PARAMS_MESSAGE;
+exports.NO_SPENDER_MESSAGE = NO_SPENDER_MESSAGE;
 exports.PortfolioFacade = PortfolioFacade;
+exports.READ_ONLY_MESSAGE = READ_ONLY_MESSAGE;
 exports.RIXON_CAPITAL = RIXON_CAPITAL;
 exports.SdkConfig = SdkConfig;
 exports.StrategiesFacade = StrategiesFacade;
 exports.UPPER_MEZZANINE = UPPER_MEZZANINE;
+exports.WithdrawFlow = WithdrawFlow;
 exports.apyToEpochRate = apyToEpochRate;
 exports.asContractType = asContractType;
 exports.auMinimumRemaining = auMinimumRemaining;
@@ -26063,6 +26926,7 @@ exports.buildFullNameRequestMessage = buildFullNameRequestMessage;
 exports.buildLegacyContractRequestMessage = buildLegacyContractRequestMessage;
 exports.buildLoanAgreementSignMessage = buildLoanAgreementSignMessage;
 exports.ceilToCents = ceilToCents;
+exports.classifyWalletFailure = classifyWalletFailure;
 exports.compareTrancheSeniority = compareTrancheSeniority;
 exports.computeSettlementWindow = computeSettlementWindow;
 exports.countSubmissions = countSubmissions;
@@ -26084,6 +26948,7 @@ exports.isBelowMinimumCapacity = isBelowMinimumCapacity;
 exports.isCycleClosed = isCycleClosed;
 exports.isUnpredictableGas = isUnpredictableGas;
 exports.isUserRejected = isUserRejected;
+exports.lastEventTimestamp = lastEventTimestamp;
 exports.maxNetRateCeiling = maxNetRateCeiling;
 exports.netEffectiveApy = netEffectiveApy;
 exports.netTrancheApyBounds = netTrancheApyBounds;