@kasufinance/kasu-sdk 2.4.2 → 2.6.0

package/src/domain/au-minimum.ts

@@ -0,0 +1,192 @@
+/**
+ * The AU cumulative-lending minimum — the numeric half.
+ *
+ * RULE: a lender whose verified KYC country is Australia may only lend when
+ * their existing deposited position on THIS deployment, plus the amount they
+ * are asking for, reaches the deployment's threshold.
+ *
+ * This is UX PRE-VALIDATION ONLY. kasu-backend enforces the rule
+ * authoritatively at contract generation and refuses with HTTP 403
+ * `AU_WHOLESALE_MINIMUM_NOT_MET`; a lender who gets past this check is still
+ * stopped there. What these helpers exist for is to raise the amount field's
+ * minimum so the lender learns the rule while typing rather than at the end.
+ *
+ * FAIL-OPEN by design: an absent or unknown country is NOT restricted, and an
+ * unlisted stable symbol has no threshold. An UNKNOWN existing position is
+ * treated as 0 — strict, so the floor is never advertised lower than the
+ * backend will accept, and it relaxes once the position loads.
+ *
+ * Arithmetic is integer bigint in minor units (10^decimals) so no two
+ * consumers can disagree at the boundary. Parsing TRUNCATES, never rounds up —
+ * a position can never be inflated into passing. `BigInt(...)` calls only, no
+ * bigint literals, so consumers on an older target still compile.
+ *
+ * Lifted from kasu-ui's `features/lending/lib/au-lending-restriction.ts`. The
+ * two toast strings that live there are copy and stay in the applications.
+ */
+
+type Maybe<T> = T | null | undefined;
+type NumLike = string | number | null | undefined;
+
+const ZERO = BigInt(0);
+
+/** ISO 3166-1 alpha-3 for Australia — the collapsed KYC country field. */
+export const AU_ALPHA3 = 'AUS';
+
+/**
+ * Is this the Australian KYC country? Case-insensitive and
+ * whitespace-tolerant. Anything that is not a string — including the
+ * `undefined` of an unloaded KYC record — is not restricted (fail-open).
+ *
+ * The alpha-2 `'AU'` deliberately does NOT match: the KYC country reaching
+ * this rule is normalised to alpha-3 upstream, and a bare two-letter code
+ * here means something else went wrong.
+ */
+export function isAustralianKyc(country: Maybe<string>): boolean {
+    if (typeof country !== 'string') return false;
+    return country.trim().toUpperCase() === AU_ALPHA3;
+}
+
+/**
+ * Minimum CUMULATIVE position, in WHOLE stable units, keyed on the
+ * deployment's stable-asset symbol (a property of the currency, not the
+ * chain). Must match kasu-backend's table exactly.
+ */
+export const AU_MIN_CUMULATIVE_BY_STABLE: Readonly<Record<string, number>> = {
+    USDC: 360_000,
+    AUDD: 500_000,
+};
+
+/**
+ * Threshold in whole units, or `undefined` for an unlisted stable — a
+ * deployment whose currency has no configured minimum is unrestricted.
+ */
+export function auThresholdFor(symbol: Maybe<string>): number | undefined {
+    if (typeof symbol !== 'string') return undefined;
+    return AU_MIN_CUMULATIVE_BY_STABLE[symbol.trim().toUpperCase()];
+}
+
+/**
+ * Is this wallet released from the minimum entirely, whatever its country,
+ * stable or position says?
+ *
+ * `exemptAddresses` is DEPLOYMENT CONFIGURATION the caller supplies, not a
+ * constant of this package. kasu-sdk is published publicly; the exempt list is
+ * a compliance carve-out naming particular lender wallets, so it does not
+ * belong in a public tarball. Read it from wherever the application keeps its
+ * deployment configuration, and keep it identical to kasu-backend's
+ * `AU_WHOLESALE_EXEMPT_ADDRESSES` — that is where the rule is actually
+ * enforced. An address exempt here but not there sees no raised minimum in the
+ * form and is refused at the end, which is worse than not exempting it at all.
+ *
+ * The address matched must be the CONNECTED wallet — the one that owns the KYC
+ * record and signs the agreement request. kasu-backend verifies that signature
+ * before the gate, so an exemption cannot be claimed by asserting someone
+ * else's address; it takes their private key. Never match a "view as" address.
+ *
+ * Comparison is case-insensitive and whitespace-tolerant. Anything that is not
+ * a string is NOT exempt (fail closed), and so is anything when the list is
+ * absent.
+ */
+export function isAuMinimumExempt(
+    address: Maybe<string>,
+    exemptAddresses: Maybe<readonly string[]>,
+): boolean {
+    if (typeof address !== 'string' || !exemptAddresses) return false;
+    const needle = address.trim().toLowerCase();
+    return exemptAddresses.some((a) => a.trim().toLowerCase() === needle);
+}
+
+const DECIMAL_RE = /^(\d+)?(?:\.(\d*))?$/;
+
+/**
+ * Truncating, partial-input-tolerant decimal → minor-unit parse.
+ * `'10.'` → `10000000n` · `'1.23456789'` → `1234567n` (truncated at 6dp).
+ * `''` / `'abc'` / negative / null → `null`.
+ *
+ * Tolerant of mid-typing states because it runs on an amount field as the
+ * lender types, and truncating because rounding up would let a position that
+ * is a fraction short read as passing.
+ */
+export function parseMinorUnits(
+    value: NumLike,
+    decimals: number,
+): bigint | null {
+    if (value === null || value === undefined) return null;
+    const raw = typeof value === 'number' ? String(value) : value.trim();
+    if (!raw) return null;
+    const match = DECIMAL_RE.exec(raw);
+    if (!match || (!match[1] && !match[2])) return null;
+    // Both capture groups are optional, so either can be absent at runtime.
+    // A fractional group that matched EMPTY ('10.') is not absent, and the
+    // destructuring defaults leave it alone — only `undefined` takes them.
+    const [, whole = '0', fracDigits = ''] = match;
+    const frac = fracDigits.slice(0, decimals).padEnd(decimals, '0');
+    return BigInt(whole + frac);
+}
+
+export interface AuMinimumInput {
+    /** Collapsed KYC country (alpha-3). Missing/undefined ⇒ not restricted. */
+    country: Maybe<string>;
+    /**
+     * The CONNECTED wallet (never a "view as" override).
+     *
+     * REQUIRED KEY, nullable value. A caller with no wallet passes `undefined`
+     * and gets the un-exempted behaviour; what it may not do is silently omit
+     * the key. Optional would let a refactor of the call site drop it with no
+     * compile error — and because a form's own minimum validation refuses a
+     * submit below the floor, an exempt lender would then be stopped HERE and
+     * never reach the backend that would have let them through.
+     */
+    address: Maybe<string>;
+    /**
+     * The deployment's exempt wallets — see `isAuMinimumExempt`. REQUIRED KEY
+     * for the same reason `address` is: a caller that has no list passes
+     * `undefined` deliberately, and no refactor can drop it by accident.
+     */
+    exemptAddresses: Maybe<readonly string[]>;
+    /** Deployment stable-asset symbol, e.g. `'USDC'` / `'AUDD'`. */
+    stableSymbol: Maybe<string>;
+    /** Stable-asset decimals (6 on every current deployment). */
+    decimals: number;
+    /**
+     * Existing position (active + pending) on THIS deployment, whole units.
+     * Unparseable/undefined ⇒ treated as 0 (strict: the full threshold applies
+     * until the position is known).
+     */
+    existingDeposited: NumLike;
+}
+
+/**
+ * The amount, in WHOLE stable units, an Australian lender still needs in order
+ * to reach the deployment's cumulative minimum. Apply it as the amount field's
+ * floor via `max(trancheMin, auMinimumRemaining(...))`.
+ *
+ * Returns 0 for everyone the rule does not restrict (fail-open), 0 for an
+ * exempt address, and 0 once the lender's existing position already satisfies
+ * the threshold.
+ *
+ * The exemption is tested FIRST and unconditionally: an exempt wallet has no
+ * minimum whatever its country, stable or position says. kasu-backend
+ * deliberately tests country first and the exemption second — the two orders
+ * are not in conflict, both return "no minimum" for the same inputs. There,
+ * the exemption sets a flag that drives a compliance log, so it must not fire
+ * for a lender the rule never engaged for. Here nothing is logged, so
+ * exemption-first is preferred: it makes this function right on its own,
+ * whatever country a caller happens to pass.
+ */
+export function auMinimumRemaining(input: AuMinimumInput): number {
+    if (isAuMinimumExempt(input.address, input.exemptAddresses)) return 0;
+    if (!isAustralianKyc(input.country)) return 0;
+    const threshold = auThresholdFor(input.stableSymbol);
+    if (threshold === undefined) return 0;
+    const { existingDeposited, decimals } = input;
+    // A table threshold always parses; `?? ZERO` keeps the rule fail-open
+    // rather than asserting, so an unparseable one yields no minimum at all.
+    const thresholdMinor = parseMinorUnits(threshold, decimals) ?? ZERO;
+    const existingMinor = parseMinorUnits(existingDeposited, decimals) ?? ZERO;
+    const remaining = thresholdMinor - existingMinor;
+    if (remaining <= ZERO) return 0;
+    const base = BigInt('1' + '0'.repeat(decimals));
+    return Number(remaining / base) + Number(remaining % base) / Number(base);
+}

package/src/domain/deposit-bounds.test.ts

@@ -0,0 +1,200 @@
+import * as fc from 'fast-check';
+
+import { TrancheData } from '../services/DataService/types';
+
+import {
+    ceilToCents,
+    floorToCents,
+    isBelowMinimumCapacity,
+    MAX_LENDING_AMOUNT_FALLBACK,
+    MIN_LENDING_AMOUNT_FALLBACK,
+    parseTrancheBound,
+    resolveBoundShortcuts,
+    resolveDepositBounds,
+} from './deposit-bounds';
+
+/**
+ * Ported from kasu-ui `src/features/lending/lib/tranche-bounds.property.test.ts`,
+ * with the `resolveDepositBounds` / `parseTrancheBound` cases the property file
+ * did not cover.
+ *
+ * The Min/Max shortcuts (clickable bound labels on a lend form) must never
+ * write an amount the form rejects, so the snapping is checked as invariants
+ * over the whole input domain rather than at a few hand-picked values.
+ */
+
+function tranche(over: Partial<TrancheData>): TrancheData {
+    return {
+        minimumDeposit: '500',
+        maximumDeposit: '500000',
+        poolCapacity: '250000',
+        ...over,
+    } as unknown as TrancheData;
+}
+
+const amountArb = fc.double({
+    min: 0,
+    max: 1e12,
+    noNaN: true,
+    noDefaultInfinity: true,
+});
+/** `String(k / 100)` prints at most two decimals for any integer `k` in range. */
+const AT_MOST_TWO_DP = /^\d+(\.\d{1,2})?$/;
+
+describe('parseTrancheBound', () => {
+    it('accepts a positive finite bound from a string or a number', () => {
+        expect(parseTrancheBound('500')).toBe(500);
+        expect(parseTrancheBound(500)).toBe(500);
+    });
+
+    it('rejects anything that is not a usable bound', () => {
+        expect(parseTrancheBound(null)).toBeNull();
+        expect(parseTrancheBound(undefined)).toBeNull();
+        expect(parseTrancheBound('')).toBeNull();
+        expect(parseTrancheBound('0')).toBeNull();
+        expect(parseTrancheBound('-1')).toBeNull();
+        expect(parseTrancheBound('not-a-number')).toBeNull();
+        expect(parseTrancheBound(Infinity)).toBeNull();
+    });
+});
+
+describe('resolveDepositBounds', () => {
+    it('clamps the max by the tranche’s REMAINING capacity', () => {
+        // A tranche can fill mid-epoch while `maximumDeposit` stays put.
+        expect(
+            resolveDepositBounds(
+                tranche({ maximumDeposit: '500000', poolCapacity: '25285.86' }),
+            ),
+        ).toEqual({ minDeposit: 500, maxDeposit: 25285.86 });
+    });
+
+    it('keeps the configured max when capacity is larger', () => {
+        expect(
+            resolveDepositBounds(
+                tranche({ maximumDeposit: '500000', poolCapacity: '900000' }),
+            ),
+        ).toEqual({ minDeposit: 500, maxDeposit: 500000 });
+    });
+
+    it('falls back when a "coming soon" pool has no bounds configured', () => {
+        expect(
+            resolveDepositBounds(
+                tranche({
+                    minimumDeposit: '0',
+                    maximumDeposit: '0',
+                    poolCapacity: '900000',
+                }),
+            ),
+        ).toEqual({
+            minDeposit: MIN_LENDING_AMOUNT_FALLBACK,
+            maxDeposit: MAX_LENDING_AMOUNT_FALLBACK,
+        });
+    });
+
+    it('uses both fallbacks and skips the capacity clamp with no tranche at all', () => {
+        expect(resolveDepositBounds(undefined)).toEqual({
+            minDeposit: MIN_LENDING_AMOUNT_FALLBACK,
+            maxDeposit: MAX_LENDING_AMOUNT_FALLBACK,
+        });
+    });
+
+    it('treats unparseable or negative capacity as zero', () => {
+        expect(
+            resolveDepositBounds(tranche({ poolCapacity: 'not-a-number' }))
+                .maxDeposit,
+        ).toBe(0);
+        expect(
+            resolveDepositBounds(tranche({ poolCapacity: '-5' })).maxDeposit,
+        ).toBe(0);
+    });
+});
+
+describe('cent snapping', () => {
+    it('floorToCents never exceeds its input, stays within a cent of it, and has ≤ 2dp', () => {
+        fc.assert(
+            fc.property(amountArb, (n) => {
+                const snapped = floorToCents(n);
+                expect(snapped).toBeLessThanOrEqual(n);
+                expect(n - snapped).toBeLessThan(0.02);
+                expect(String(snapped)).toMatch(AT_MOST_TWO_DP);
+            }),
+        );
+    });
+
+    it('ceilToCents never undershoots its input, stays within a cent of it, and has ≤ 2dp', () => {
+        fc.assert(
+            fc.property(amountArb, (n) => {
+                const snapped = ceilToCents(n);
+                expect(snapped).toBeGreaterThanOrEqual(n);
+                expect(snapped - n).toBeLessThan(0.02);
+                expect(String(snapped)).toMatch(AT_MOST_TWO_DP);
+            }),
+        );
+    });
+});
+
+describe('resolveBoundShortcuts', () => {
+    it('keeps both shortcuts inside the validated range whenever they are enabled', () => {
+        fc.assert(
+            fc.property(amountArb, amountArb, (minDeposit, maxDeposit) => {
+                const { min, max, enabled } = resolveBoundShortcuts(
+                    minDeposit,
+                    maxDeposit,
+                );
+                if (!enabled) return;
+                expect(min).toBeGreaterThanOrEqual(minDeposit);
+                expect(max).toBeLessThanOrEqual(maxDeposit);
+                expect(max).toBeGreaterThanOrEqual(min);
+                expect(max).toBeGreaterThan(0);
+            }),
+        );
+    });
+
+    it('disables the pair whenever the snapped range is empty', () => {
+        // Tranche at capacity (max clamps to 0), sub-cent dust the SDK's float
+        // subtraction leaves behind, remaining capacity below the tranche
+        // minimum, and an AU floor above the capacity.
+        expect(resolveBoundShortcuts(500, 0).enabled).toBe(false);
+        expect(
+            resolveBoundShortcuts(500, 1.4551915228366852e-11).enabled,
+        ).toBe(false);
+        expect(resolveBoundShortcuts(500, 137).enabled).toBe(false);
+        expect(resolveBoundShortcuts(240_000, 100_000).enabled).toBe(false);
+    });
+
+    it('snaps SDK float noise onto cents without crossing the bound', () => {
+        expect(resolveBoundShortcuts(500, 249999.99999999997)).toEqual({
+            min: 500,
+            max: 249999.99,
+            enabled: true,
+        });
+        expect(resolveBoundShortcuts(500, 25285.86)).toEqual({
+            min: 500,
+            max: 25285.86,
+            enabled: true,
+        });
+        // An AU remainder with more precision than the field shows rounds UP.
+        expect(resolveBoundShortcuts(358765.432109, 500_000).min).toBe(
+            358765.44,
+        );
+    });
+});
+
+describe('isBelowMinimumCapacity', () => {
+    it('is exactly the negation of the shortcuts being enabled', () => {
+        fc.assert(
+            fc.property(amountArb, amountArb, (minDeposit, maxDeposit) => {
+                // The "nothing to click" and "nothing to type" states must
+                // never be able to disagree.
+                expect(isBelowMinimumCapacity(minDeposit, maxDeposit)).toBe(
+                    !resolveBoundShortcuts(minDeposit, maxDeposit).enabled,
+                );
+            }),
+        );
+    });
+
+    it('flags a capacity that has fallen under the tranche minimum', () => {
+        expect(isBelowMinimumCapacity(500, 137)).toBe(true);
+        expect(isBelowMinimumCapacity(500, 25285.86)).toBe(false);
+    });
+});

package/src/domain/deposit-bounds.ts

@@ -0,0 +1,118 @@
+import { TrancheData } from '../services/DataService/types';
+
+// Fallbacks if the selected tranche's on-chain min/max are 0 / NaN (some
+// "coming soon" pools haven't been configured yet).
+export const MIN_LENDING_AMOUNT_FALLBACK = 500;
+export const MAX_LENDING_AMOUNT_FALLBACK = 500_000;
+
+export function parseTrancheBound(
+    raw: string | number | null | undefined,
+): number | null {
+    if (raw == null) return null;
+    const n = typeof raw === 'string' ? parseFloat(raw) : raw;
+    return Number.isFinite(n) && n > 0 ? n : null;
+}
+
+export interface DepositBounds {
+    minDeposit: number;
+    maxDeposit: number;
+}
+
+/**
+ * Min + max lending amount (in whole stable units) for a tranche. The max is
+ * clamped by the tranche's *remaining* capacity: a tranche can fill mid-epoch
+ * while `maximumDeposit` stays at its configured value, so without the clamp
+ * a form would accept an amount the contract will reject. Mirrors
+ * kasu-fe-next's `calculateDepositMinMax` (`trancheMax = min(max, capacity)`).
+ */
+export function resolveDepositBounds(
+    tranche: TrancheData | undefined,
+): DepositBounds {
+    const minDeposit =
+        parseTrancheBound(tranche?.minimumDeposit) ??
+        MIN_LENDING_AMOUNT_FALLBACK;
+    const configuredMax =
+        parseTrancheBound(tranche?.maximumDeposit) ??
+        MAX_LENDING_AMOUNT_FALLBACK;
+    if (!tranche) return { minDeposit, maxDeposit: configuredMax };
+    const remainingCapacity = Math.max(
+        0,
+        parseFloat(tranche.poolCapacity) || 0,
+    );
+    return { minDeposit, maxDeposit: Math.min(configuredMax, remainingCapacity) };
+}
+
+export interface BoundShortcuts {
+    min: number;
+    max: number;
+    enabled: boolean;
+}
+
+/**
+ * The values a lend form's clickable Min/Max labels write into the amount
+ * field. Derived from the validated bounds but snapped to whole cents
+ * CONSERVATIVELY — the min rounds UP, the max rounds DOWN — so a shortcut can
+ * never fill an amount the form's own `min ≤ amount ≤ max` check rejects, and
+ * never carries the SDK's float noise into the field (`targetDrawAmount -
+ * pendingDeposits` routinely yields `249999.99999999997`, which would make the
+ * label, the field's 2dp display and the signed request label all disagree).
+ *
+ * `enabled` is false when the snapped range is empty: a tranche at capacity
+ * (max clamps to 0 or to sub-cent dust), a remaining capacity below the
+ * tranche minimum, or a jurisdiction floor above the capacity. Nothing either
+ * shortcut could write would validate, so both render inert.
+ */
+export function resolveBoundShortcuts(
+    minDeposit: number,
+    maxDeposit: number,
+): BoundShortcuts {
+    const min = ceilToCents(minDeposit);
+    const max = floorToCents(maxDeposit);
+    const enabled =
+        Number.isFinite(min) && Number.isFinite(max) && max > 0 && max >= min;
+    return { min, max, enabled };
+}
+
+/**
+ * True when no amount exists that satisfies both bounds — the minimum sits
+ * ABOVE the maximum, so the range a form would otherwise print ("Min 360,000 ·
+ * Max 25,285") is a contradiction, not an instruction. Happens when a
+ * tranche's remaining capacity falls under its own configured minimum, when it
+ * is at capacity (max 0 / sub-cent dust), or when the AU wholesale cumulative
+ * floor lands above the capacity that is left.
+ *
+ * Defined as the negation of `resolveBoundShortcuts().enabled` on purpose: the
+ * "there is nothing to click" and "there is nothing to type" states must never
+ * be able to disagree.
+ *
+ * This is UX only. The binding minimum is enforced by kasu-backend (403
+ * `AU_WHOLESALE_MINIMUM_NOT_MET`) and by the contract's own bounds; nothing
+ * here may be used to relax either.
+ */
+export function isBelowMinimumCapacity(
+    minDeposit: number,
+    maxDeposit: number,
+): boolean {
+    return !resolveBoundShortcuts(minDeposit, maxDeposit).enabled;
+}
+
+const CENTS = 100;
+
+/**
+ * Largest whole-cent value ≤ `n`. Float multiplication can round `n * 100` UP
+ * onto an integer (`1.15 * 100 === 114.99999999999999` is the usual direction,
+ * but the other happens too), so the result is re-checked against `n` and
+ * stepped down a cent if it overshot — the contract is "never above `n`".
+ */
+export function floorToCents(n: number): number {
+    const k = Math.floor(n * CENTS);
+    const snapped = k / CENTS;
+    return snapped > n ? (k - 1) / CENTS : snapped;
+}
+
+/** Smallest whole-cent value ≥ `n`. Mirror of `floorToCents`: never below `n`. */
+export function ceilToCents(n: number): number {
+    const k = Math.ceil(n * CENTS);
+    const snapped = k / CENTS;
+    return snapped < n ? (k + 1) / CENTS : snapped;
+}

package/src/domain/index.ts

@@ -0,0 +1,134 @@
+/**
+ * The shared domain layer: the rules every Kasu frontend needs to agree on,
+ * in one place instead of three.
+ *
+ * Two rules govern what may live here.
+ *
+ * 1. **Numbers and codes only.** No copy, no locale, no `Intl`, no string a
+ *    user reads — `netEffectiveApy` returns `0.196`, never `'19.60% p.a.'`,
+ *    and `derivePoolStatus` returns the code `'Full'`, not a sentence. The
+ *    formatters that turn these into text stay in each app, where the design
+ *    system and the visitor's locale are.
+ *
+ *    Two kinds of string are exempt, and only these two. `getTrancheDisplayName`
+ *    is here precisely because that rename must NOT drift between apps. And
+ *    `loan-contract.ts` builds PROTOCOL strings — messages kasu-backend
+ *    reconstructs byte-for-byte to verify a lender's signature. Those are not
+ *    copy: nobody may reword them, in any language, without a matching backend
+ *    change, which is exactly why they belong in one place.
+ * 2. **Pure.** No network, no clock, no environment. Anything with I/O belongs
+ *    in `facade/` (see `fetchUnusedPoolIds`).
+ */
+export {
+    apyToEpochRate,
+    epochRateToApy,
+    EPOCHS_IN_YEAR,
+    netEffectiveApy,
+} from './rates';
+
+export {
+    AU_ALPHA3,
+    AU_MIN_CUMULATIVE_BY_STABLE,
+    auMinimumRemaining,
+    auThresholdFor,
+    isAuMinimumExempt,
+    isAustralianKyc,
+    parseMinorUnits,
+} from './au-minimum';
+export type { AuMinimumInput } from './au-minimum';
+
+export {
+    ceilToCents,
+    floorToCents,
+    isBelowMinimumCapacity,
+    MAX_LENDING_AMOUNT_FALLBACK,
+    MIN_LENDING_AMOUNT_FALLBACK,
+    parseTrancheBound,
+    resolveBoundShortcuts,
+    resolveDepositBounds,
+} from './deposit-bounds';
+export type { BoundShortcuts, DepositBounds } from './deposit-bounds';
+
+export {
+    APXIUM,
+    getCreditOriginator,
+    getInstitutionalLender,
+    INVOICEMATE,
+    RIXON_CAPITAL,
+} from './partners';
+export type { PoolNameSignal, StrategyPartner } from './partners';
+
+export {
+    asContractType,
+    buildContractVersionType,
+    buildFullNameRequestMessage,
+    buildLegacyContractRequestMessage,
+    buildLoanAgreementSignMessage,
+    encodeDepositData,
+    formatSignTimestampUtc,
+    parseFormattedMessage,
+} from './loan-contract';
+export type {
+    ContractListItem,
+    ContractSection,
+    ContractType,
+    ExemptLoanContract,
+    GenerateContractResponse,
+    LoanContractFormatted,
+    ResolvedContractResponse,
+    RetailLoanContract,
+} from './loan-contract';
+
+export {
+    maxNetRateCeiling,
+    pickHighestYieldTranche,
+    poolMaxApy,
+    selectVisiblePools,
+} from './pools';
+export type { BestTranche } from './pools';
+
+export {
+    countSubmissions,
+    deriveRequestState,
+    firstSubmissionTimestamp,
+    isCycleClosed,
+    submissionEvents,
+} from './requests';
+export type {
+    RequestKind,
+    RequestState,
+    RequestStatusCode,
+} from './requests';
+
+export {
+    CLEARING_WINDOW_SECONDS,
+    computeSettlementWindow,
+    deriveCycleDates,
+    nextCycleBoundary,
+} from './settlement';
+export type {
+    CycleDates,
+    SettlementWindowInput,
+    SettlementWindowState,
+} from './settlement';
+
+export { getTrancheDisplayName, UPPER_MEZZANINE } from './tranche-display-name';
+
+export {
+    compareTrancheSeniority,
+    derivePoolStatus,
+    MIN_TRANCHE_CAPACITY,
+    netTrancheApyBounds,
+    pickDefaultTrancheId,
+    poolAllTranchesFull,
+    trancheApyBounds,
+    trancheHasCapacity,
+    trancheRiskRank,
+} from './tranches';
+export type {
+    ApyBounds,
+    PoolStatus,
+    TrancheCapacitySignal,
+} from './tranches';
+
+export { isUnpredictableGas, isUserRejected } from './wallet-errors';