@kasufinance/kasu-sdk 2.5.0 → 2.7.0

package/dist/flows/flow.d.ts

@@ -0,0 +1,72 @@
+import { FlowStore } from './observable';
+/**
+ * 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.
+ */
+export declare abstract class Flow<S, I> {
+    protected readonly _store: FlowStore<S>;
+    /**
+     * 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.
+     */
+    private _runToken;
+    protected constructor(initial: S);
+    /** The current state. Every transition is also published to `subscribe`. */
+    get state(): S;
+    /** True while a run is in flight, including while parked. */
+    get isRunning(): boolean;
+    /**
+     * Observe every transition. Returns the unsubscribe function.
+     *
+     * The listener is not called on subscribe; read `state` for the value it
+     * starts from.
+     */
+    subscribe(listener: (state: S) => void): () => void;
+    /**
+     * 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: I): Promise<void>;
+    /**
+     * 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(): void;
+    /**
+     * 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.
+     */
+    protected _onAbandon(): void;
+    /** The pipeline itself. `token` is this run's; check it after every await. */
+    protected abstract _run(input: I, token: number): Promise<void>;
+}

package/dist/flows/flow.js

@@ -0,0 +1,110 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { FlowStore } from './observable';
+/**
+ * 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.
+ */
+export 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.
+    }
+}
+//# sourceMappingURL=flow.js.map

package/dist/flows/flow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.js","sourceRoot":"","sources":["../../src/flows/flow.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,OAAgB,IAAI;IAUtB,YAAsB,OAAU;QAPhC;;;;WAIG;QACK,cAAS,GAAkB,IAAI,CAAC;QAGpC,IAAI,CAAC,MAAM,GAAG,IAAI,SAAS,CAAI,OAAO,CAAC,CAAC;IAC5C,CAAC;IAED,4EAA4E;IAC5E,IAAI,KAAK;QACL,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;IAC7B,CAAC;IAED,6DAA6D;IAC7D,IAAI,SAAS;QACT,OAAO,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC;IACnC,CAAC;IAED;;;;;OAKG;IACH,SAAS,CAAC,QAA4B;QAClC,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;;OAMG;IACG,KAAK,CAAC,KAAQ;;YAChB,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI;gBAAE,OAAO;YACpC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;YACpB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACrC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;YACvB,IAAI,CAAC;gBACD,MAAM,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YAClC,CAAC;oBAAS,CAAC;gBACP,IAAI,IAAI,CAAC,SAAS,KAAK,KAAK;oBAAE,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;YACxD,CAAC;QACL,CAAC;KAAA;IAED;;;;;;OAMG;IACH,KAAK;QACD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,oEAAoE;QACpE,0CAA0C;QAC1C,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QACpB,IAAI,CAAC,UAAU,EAAE,CAAC;IACtB,CAAC;IAED;;;;OAIG;IACO,UAAU;QAChB,oDAAoD;IACxD,CAAC;CAIJ"}

package/dist/flows/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Flows: the headless money-path state machines.
+ *
+ * `domain/` holds rules that are pure functions. These are the same idea one
+ * level up — a rule that unfolds over time, with side effects the consumer
+ * injects as ports. They own the ORDER of a deposit and a withdrawal, the
+ * guards around them, and the codes that describe where a run got to. They own
+ * no UI, no framework, no network and no words.
+ *
+ * Every application drove its own copy of the deposit pipeline before this, and
+ * the copies had already started to differ.
+ */
+export { Flow } from './flow';
+export { FlowStore } from './observable';
+export type { WaitableTransaction } from './observable';
+export { CONTRACT_TTL_MS, DepositFlow, NO_SPENDER_MESSAGE, } from './deposit-flow';
+export type { ContractMessageRequest, DepositFailure, DepositFlowInput, DepositFlowOptions, DepositPhase, DepositPorts, DepositState, DepositStep, GenerateContractRequest, KycSignature, LegacyContractRequest, LoanAgreementRequest, } from './deposit-flow';
+export { NO_KYC_PARAMS_MESSAGE, WithdrawFlow } from './withdraw-flow';
+export type { WithdrawFailure, WithdrawFlowInput, WithdrawPhase, WithdrawPorts, WithdrawState, WithdrawStep, } from './withdraw-flow';

package/dist/flows/index.js

@@ -0,0 +1,17 @@
+/**
+ * Flows: the headless money-path state machines.
+ *
+ * `domain/` holds rules that are pure functions. These are the same idea one
+ * level up — a rule that unfolds over time, with side effects the consumer
+ * injects as ports. They own the ORDER of a deposit and a withdrawal, the
+ * guards around them, and the codes that describe where a run got to. They own
+ * no UI, no framework, no network and no words.
+ *
+ * Every application drove its own copy of the deposit pipeline before this, and
+ * the copies had already started to differ.
+ */
+export { Flow } from './flow';
+export { FlowStore } from './observable';
+export { CONTRACT_TTL_MS, DepositFlow, NO_SPENDER_MESSAGE, } from './deposit-flow';
+export { NO_KYC_PARAMS_MESSAGE, WithdrawFlow } from './withdraw-flow';
+//# sourceMappingURL=index.js.map

package/dist/flows/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/flows/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAGzC,OAAO,EACH,eAAe,EACf,WAAW,EACX,kBAAkB,GACrB,MAAM,gBAAgB,CAAC;AAgBxB,OAAO,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/flows/observable.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 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.
+ */
+export declare class FlowStore<S> {
+    private readonly _initial;
+    private _state;
+    private _generation;
+    private readonly _listeners;
+    constructor(_initial: S);
+    get state(): S;
+    /** The run token an in-flight pipeline captures at `start()`. */
+    get generation(): number;
+    /** False once `reset()` (or a later `start()`) has superseded `token`. */
+    isCurrent(token: number): boolean;
+    /**
+     * 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: (state: S) => void): () => void;
+    /**
+     * Merge `next` into the state and notify, unless `token` names a
+     * superseded run.
+     */
+    patch(next: Partial<S>, token?: number): void;
+    /**
+     * 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(): void;
+    /** Claim the next run token. Any earlier run is abandoned. */
+    beginRun(): number;
+}
+/**
+ * Anything with a `wait()` — an ethers `ContractTransaction`, or a fake.
+ *
+ * Lives beside the store rather than in either flow: both submit transactions
+ * through their own ports, and neither of them should have to import the
+ * other's file to say so.
+ */
+export interface WaitableTransaction {
+    wait(): Promise<unknown>;
+}

package/dist/flows/observable.js

@@ -0,0 +1,81 @@
+/**
+ * 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.
+ */
+export 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;
+    }
+}
+//# sourceMappingURL=observable.js.map

package/dist/flows/observable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observable.js","sourceRoot":"","sources":["../../src/flows/observable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,SAAS;IAKlB,YAA6B,QAAW;QAAX,aAAQ,GAAR,QAAQ,CAAG;QAHhC,gBAAW,GAAG,CAAC,CAAC;QACP,eAAU,GAAG,IAAI,GAAG,EAAsB,CAAC;QAGxD,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED,IAAI,KAAK;QACL,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED,iEAAiE;IACjE,IAAI,UAAU;QACV,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;IAED,0EAA0E;IAC1E,SAAS,CAAC,KAAa;QACnB,OAAO,IAAI,CAAC,WAAW,KAAK,KAAK,CAAC;IACtC,CAAC;IAED;;;;;;;OAOG;IACH,SAAS,CAAC,QAA4B;QAClC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC9B,OAAO,GAAG,EAAE;YACR,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACrC,CAAC,CAAC;IACN,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,IAAgB,EAAE,KAAc;QAClC,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;YAAE,OAAO;QAC1D,IAAI,CAAC,MAAM,mCAAQ,IAAI,CAAC,MAAM,GAAK,IAAI,CAAE,CAAC;QAC1C,KAAK,MAAM,QAAQ,IAAI,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YAC1C,IAAI,CAAC;gBACD,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YAC1B,CAAC;YAAC,WAAM,CAAC;gBACL,gEAAgE;gBAChE,mCAAmC;YACvC,CAAC;QACL,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,KAAK;QACD,IAAI,CAAC,WAAW,IAAI,CAAC,CAAC;QACtB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC9B,CAAC;IAED,8DAA8D;IAC9D,QAAQ;QACJ,IAAI,CAAC,WAAW,IAAI,CAAC,CAAC;QACtB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;CACJ"}

package/dist/flows/withdraw-flow.d.ts

@@ -0,0 +1,99 @@
+import { BigNumber } from 'ethers';
+import { KycParams } from '../facade/types';
+import { Flow } from './flow';
+import { WaitableTransaction } from './observable';
+/**
+ * The withdrawal pipeline, headless — the small sibling of `DepositFlow`.
+ *
+ * Much less happens here, and that is the point of it being separate: no loan
+ * agreement, no approval (the lender is handing tranche shares back, not
+ * granting a spend), no on-chain KYC payload. What survives is the shape both
+ * applications need — an observable phase, one `'max'`-aware submission, and
+ * the same `cancelled` / `failed` split, so a lender who pressed Reject is
+ * never told something broke.
+ *
+ * The run lifecycle — the re-entrancy guard, `state`, `isRunning`,
+ * `subscribe`, `reset` — is `Flow`'s, shared with the deposit pipeline. It was
+ * a second copy here until 2.7.0, which is two places for one guard to be
+ * wrong.
+ *
+ * Same house rules as the deposit flow: no React, no copy, no I/O of its own.
+ * `state` carries codes; the consumer owns every word a lender reads.
+ *
+ * ```ts
+ * const flow = new WithdrawFlow(ports);
+ * flow.subscribe(render);
+ * await flow.start({ poolId, trancheId, amount: 'max', userAddress });
+ * ```
+ */
+export type WithdrawPhase = 'idle' | 'checking-kyc' | 'request-sign' | 'request-confirm' | 'success' | 'error';
+/**
+ * `kyc` only exists when the consumer supplies `getKycSignature`. kasu-mobile
+ * does, to fail early and legibly when a lender's KYC has lapsed rather than
+ * let the on-chain call revert; kasu-ui does not.
+ */
+export type WithdrawStep = 'kyc' | 'request';
+export type WithdrawFailure = {
+    step: WithdrawStep;
+    reason: 'cancelled';
+} | {
+    step: WithdrawStep;
+    reason: 'failed';
+    error: unknown;
+};
+export interface WithdrawPorts {
+    /**
+     * Build the Nexera KYC params for the pre-check. Defaults to
+     * `kasu.deposits.buildKycParams`, exactly as the deposit flow's does.
+     */
+    buildKycParams?(userAddress: `0x${string}`): KycParams | Promise<KycParams>;
+    /**
+     * Exchange those params for a signature at the consumer's own backend, and
+     * so verify the lender's KYC BEFORE the wallet is opened — a lapsed one
+     * surfaces as `{ step: 'kyc' }` instead of an opaque revert. The
+     * withdrawal call itself does not carry the signature.
+     *
+     * Supplying this port is what turns the pre-check on; there is no default,
+     * because the SDK does not know the application's backend. This is the
+     * same pair the deposit flow uses, rather than the opaque `ensureKyc` of
+     * earlier drafts, so one KYC pre-check exists across both money paths.
+     */
+    getKycSignature?(params: KycParams): Promise<unknown>;
+    /** `requestWithdrawalInAsset`. Defaults to `kasu.deposits.withdraw`. */
+    withdraw(params: {
+        poolId: string;
+        trancheId: string;
+        amount: BigNumber;
+    }): Promise<WaitableTransaction>;
+    /** `requestWithdrawalMax`. Defaults to `kasu.deposits.withdrawMax`. */
+    withdrawMax(poolId: string, trancheId: string, userAddress: string): Promise<WaitableTransaction>;
+}
+export interface WithdrawFlowInput {
+    poolId: string;
+    trancheId: string;
+    /**
+     * The amount in BASE units, or the literal `'max'`.
+     *
+     * `'max'` is not "the balance as I last read it": it routes to the
+     * all-shares contract call, which resolves the balance on chain at
+     * execution. Deciding max-ness from a number the consumer read a moment ago
+     * is how dust gets stranded in a tranche, so the decision is a code, made
+     * by the consumer, and carried here intact.
+     */
+    amount: BigNumber | 'max';
+    userAddress: `0x${string}`;
+}
+export interface WithdrawState {
+    phase: WithdrawPhase;
+    step: WithdrawStep | null;
+    /** True when this run routed through the all-shares call. */
+    isMax: boolean;
+    failure: WithdrawFailure | null;
+}
+/** What a KYC pre-check with no `buildKycParams` to call fails with. */
+export declare const NO_KYC_PARAMS_MESSAGE = "WithdrawFlow: getKycSignature was supplied without buildKycParams; build the flow with kasu.flows.withdraw() or pass both";
+export declare class WithdrawFlow extends Flow<WithdrawState, WithdrawFlowInput> {
+    private readonly _ports;
+    constructor(_ports: WithdrawPorts);
+    protected _run(input: WithdrawFlowInput, token: number): Promise<void>;
+}

package/dist/flows/withdraw-flow.js

@@ -0,0 +1,83 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { classifyWalletFailure } from '../domain/wallet-errors';
+import { Flow } from './flow';
+const INITIAL = {
+    phase: 'idle',
+    step: null,
+    isMax: false,
+    failure: null,
+};
+/** What a KYC pre-check with no `buildKycParams` to call fails with. */
+export const NO_KYC_PARAMS_MESSAGE = 'WithdrawFlow: getKycSignature was supplied without buildKycParams; build the flow with kasu.flows.withdraw() or pass both';
+// ---------------------------------------------------------------------------
+// The flow
+// ---------------------------------------------------------------------------
+export 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);
+        });
+    }
+}
+//# sourceMappingURL=withdraw-flow.js.map

package/dist/flows/withdraw-flow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withdraw-flow.js","sourceRoot":"","sources":["../../src/flows/withdraw-flow.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -6,5 +6,7 @@ export type { UserRequest, UserRequestEvent, UserTrancheBalance, UserPoolBalance
 export type { PortfolioSummary, PortfolioLendingPool, PortfolioTranche, PortfolioRewards, PortfolioTrancheDepositDetails, } from './services/Portfolio/types';
 export type { UserLock, UserBonusData, LockPeriod, GQLGetLockingPeriods, SystemVariables, } from './services/Locking/types';
 export type { PoolOverviewDirectus, PlatformOverviewDirectus, } from './services/DataService/directus-types';
+export { NO_DIRECTUS_URL_MESSAGE } from './services/DataService/directus-client';
 export * from './facade';
 export * from './domain';
+export * from './flows';

package/dist/index.js

@@ -3,6 +3,7 @@
 // ---------------------------------------------------------------------------
 export { KasuSdk } from './kasu-sdk';
 export { SdkConfig } from './sdk-config';
+export { NO_DIRECTUS_URL_MESSAGE } from './services/DataService/directus-client';
 // ---------------------------------------------------------------------------
 // Re-export facade (high-level integrator API)
 // ---------------------------------------------------------------------------
@@ -12,4 +13,10 @@ export * from './facade';
 // only: no copy, no locale. See `src/domain/index.ts`.
 // ---------------------------------------------------------------------------
 export * from './domain';
+// ---------------------------------------------------------------------------
+// Flows — the headless deposit / withdraw state machines. No React, no copy,
+// no I/O of their own: every side effect is an injected port and every
+// observable state is a code. See `src/flows/index.ts`.
+// ---------------------------------------------------------------------------
+export * from './flows';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,4CAA4C;AAC5C,8EAA8E;AAC9E,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAMrC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAgDzC,8EAA8E;AAC9E,+CAA+C;AAC/C,8EAA8E;AAC9E,cAAc,UAAU,CAAC;AAEzB,8EAA8E;AAC9E,6EAA6E;AAC7E,uDAAuD;AACvD,8EAA8E;AAC9E,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,4CAA4C;AAC5C,8EAA8E;AAC9E,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAMrC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAgDzC,OAAO,EAAE,uBAAuB,EAAE,MAAM,wCAAwC,CAAC;AAEjF,8EAA8E;AAC9E,+CAA+C;AAC/C,8EAA8E;AAC9E,cAAc,UAAU,CAAC;AAEzB,8EAA8E;AAC9E,6EAA6E;AAC7E,uDAAuD;AACvD,8EAA8E;AAC9E,cAAc,UAAU,CAAC;AAEzB,8EAA8E;AAC9E,6EAA6E;AAC7E,uEAAuE;AACvE,wDAAwD;AACxD,8EAA8E;AAC9E,cAAc,SAAS,CAAC"}

package/dist/services/DataService/data-service.js

@@ -18,28 +18,21 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { authentication, createDirectus, readItems, readSingleton, rest, } from '@directus/sdk';
+import { readItems, readSingleton } from '@directus/sdk';
 import { formatUnits } from 'ethers/lib/utils';
 import { GraphQLClient } from 'graphql-request';
 import { KasuPoolExternalTVLAbi__factory, } from '../../contracts';
 import { epochRateToApy } from '../../domain/rates';
 import { getSystemVariablesQuery } from '../Locking/queries';
 import { filterArray } from '../shared';
+import { createDirectusClient, } from './directus-client';
 import { getAllTrancheConfigurationsQuery, getAllTranchesQuery, getLendingPoolWithdrawalAndDepositsQuery, getPoolNameQuery, getPoolOverviewQuery, } from './queries';
 export class DataService {
     constructor(_kasuConfig, signerOrProvider) {
         this._kasuConfig = _kasuConfig;
         this._externalTvlAbi = KasuPoolExternalTVLAbi__factory.connect(_kasuConfig.contracts.ExternalTVL, signerOrProvider);
         this._graph = new GraphQLClient(_kasuConfig.subgraphUrl);
-        if (_kasuConfig.directusUrl) {
-            this._directus = createDirectus(_kasuConfig.directusUrl)
-                .with(authentication())
-                .with(rest());
-        }
-        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}`;
@@ -333,7 +326,6 @@ export class DataService {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             const poolDelegateProfileAndHistoryDirectus = (yield this._directus.request(readItems('PoolDelegateProfileAndHistory', {
-                // @ts-ignore Directus' deep-fields typing is fragile across versions
                 fields: ['*', { otherPools: ['*'] }],
             })));
             const [poolNames, directusPoolNames] = yield Promise.all([