@kasufinance/kasu-sdk 2.5.0 → 2.7.0

package/dist/domain/au-minimum.d.ts

@@ -0,0 +1,135 @@
+/**
+ * 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;
+/** ISO 3166-1 alpha-3 for Australia — the collapsed KYC country field. */
+export declare 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 declare function isAustralianKyc(country: Maybe<string>): boolean;
+/**
+ * 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 declare const AU_MIN_CUMULATIVE_BY_STABLE: Readonly<Record<string, number>>;
+/**
+ * Threshold in whole units, or `undefined` for an unlisted stable — a
+ * deployment whose currency has no configured minimum is unrestricted.
+ */
+export declare function auThresholdFor(symbol: Maybe<string>): number | undefined;
+/**
+ * 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 declare function isAuMinimumExempt(address: Maybe<string>, exemptAddresses: Maybe<readonly string[]>): boolean;
+/**
+ * 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 declare function parseMinorUnits(value: NumLike, decimals: number): bigint | null;
+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 declare function auMinimumRemaining(input: AuMinimumInput): number;
+export {};

package/dist/domain/au-minimum.js

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

package/dist/domain/au-minimum.js.map

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

package/dist/domain/index.d.ts

@@ -8,19 +8,34 @@
  *    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. The one exception is
- *    `getTrancheDisplayName`, which exists precisely because that rename must
- *    NOT drift between apps.
+ *    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, lastEventTimestamp, 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 { classifyWalletFailure, isUnpredictableGas, isUserRejected, } from './wallet-errors';
+export type { WalletFailure } from './wallet-errors';

package/dist/domain/index.js

@@ -8,16 +8,26 @@
  *    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. The one exception is
- *    `getTrancheDisplayName`, which exists precisely because that rename must
- *    NOT drift between apps.
+ *    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 { ceilToCents, floorToCents, isBelowMinimumCapacity, MAX_LENDING_AMOUNT_FALLBACK, MIN_LENDING_AMOUNT_FALLBACK, parseTrancheBound, resolveBoundShortcuts, resolveDepositBounds, } from './deposit-bounds';
 export { APXIUM, getCreditOriginator, getInstitutionalLender, INVOICEMATE, RIXON_CAPITAL, } from './partners';
+export { asContractType, buildContractVersionType, buildFullNameRequestMessage, buildLegacyContractRequestMessage, buildLoanAgreementSignMessage, encodeDepositData, formatSignTimestampUtc, parseFormattedMessage, } from './loan-contract';
 export { maxNetRateCeiling, pickHighestYieldTranche, poolMaxApy, selectVisiblePools, } from './pools';
+export { countSubmissions, deriveRequestState, firstSubmissionTimestamp, isCycleClosed, lastEventTimestamp, submissionEvents, } from './requests';
+export { CLEARING_WINDOW_SECONDS, computeSettlementWindow, deriveCycleDates, nextCycleBoundary, } 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 { classifyWalletFailure, isUnpredictableGas, isUserRejected, } from './wallet-errors';
 //# sourceMappingURL=index.js.map

package/dist/domain/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/domain/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EACH,cAAc,EACd,cAAc,EACd,cAAc,EACd,eAAe,GAClB,MAAM,SAAS,CAAC;AAEjB,OAAO,EACH,WAAW,EACX,YAAY,EACZ,sBAAsB,EACtB,2BAA2B,EAC3B,2BAA2B,EAC3B,iBAAiB,EACjB,qBAAqB,EACrB,oBAAoB,GACvB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACH,MAAM,EACN,mBAAmB,EACnB,sBAAsB,EACtB,WAAW,EACX,aAAa,GAChB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACH,iBAAiB,EACjB,uBAAuB,EACvB,UAAU,EACV,kBAAkB,GACrB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEhF,OAAO,EACH,uBAAuB,EACvB,gBAAgB,EAChB,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,GAClB,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/domain/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EACH,cAAc,EACd,cAAc,EACd,cAAc,EACd,eAAe,GAClB,MAAM,SAAS,CAAC;AAEjB,OAAO,EACH,SAAS,EACT,2BAA2B,EAC3B,kBAAkB,EAClB,cAAc,EACd,iBAAiB,EACjB,eAAe,EACf,eAAe,GAClB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACH,WAAW,EACX,YAAY,EACZ,sBAAsB,EACtB,2BAA2B,EAC3B,2BAA2B,EAC3B,iBAAiB,EACjB,qBAAqB,EACrB,oBAAoB,GACvB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACH,MAAM,EACN,mBAAmB,EACnB,sBAAsB,EACtB,WAAW,EACX,aAAa,GAChB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACH,cAAc,EACd,wBAAwB,EACxB,2BAA2B,EAC3B,iCAAiC,EACjC,6BAA6B,EAC7B,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,GACxB,MAAM,iBAAiB,CAAC;AAYzB,OAAO,EACH,iBAAiB,EACjB,uBAAuB,EACvB,UAAU,EACV,kBAAkB,GACrB,MAAM,SAAS,CAAC;AAGjB,OAAO,EACH,gBAAgB,EAChB,kBAAkB,EAClB,wBAAwB,EACxB,aAAa,EACb,kBAAkB,EAClB,gBAAgB,GACnB,MAAM,YAAY,CAAC;AAOpB,OAAO,EACH,uBAAuB,EACvB,uBAAuB,EACvB,gBAAgB,EAChB,iBAAiB,GACpB,MAAM,cAAc,CAAC;AAOtB,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEhF,OAAO,EACH,uBAAuB,EACvB,gBAAgB,EAChB,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,GAClB,MAAM,YAAY,CAAC;AAOpB,OAAO,EACH,qBAAqB,EACrB,kBAAkB,EAClB,cAAc,GACjB,MAAM,iBAAiB,CAAC"}

package/dist/domain/loan-contract.d.ts

@@ -0,0 +1,174 @@
+/**
+ * Loan-contract protocol: the strings and the bytes kasu-backend verifies.
+ *
+ * ⚠️ THE ONE EXCEPTION TO "NUMBERS AND CODES ONLY". Everything this module
+ * returns as a string is a PROTOCOL string, not copy. The backend reconstructs
+ * each of these messages byte-for-byte and verifies the lender's signature
+ * against it; a changed word, separator, line break or date format does not
+ * read differently — it stops every signature verifying. They are here, in the
+ * shared layer, for exactly the reason `getTrancheDisplayName` is: so the
+ * applications cannot drift apart on them.
+ *
+ * Any change to a builder below is a coordinated multi-repo change that has to
+ * land in kasu-backend at the same moment. Do not "tidy" this file.
+ *
+ * Lifted from kasu-ui's `features/lending/lib/{contract-types, sign-message}.ts`
+ * and `encode-deposit-data.ts` — the last rewritten from viem to ethers v5
+ * (kasu-mobile already runs that port; the tests pin the two byte-identical).
+ */
+/** Recursive list nesting: `list-N-list`, etc. — indexed by string keys. */
+export type ContractListItem = {
+    label?: string;
+    description?: string;
+} & Record<string, unknown>;
+export type ContractSection = {
+    title?: string;
+    description?: string;
+} & Record<`list-${number}`, ContractListItem | undefined> & Record<string, unknown>;
+export type RetailLoanContract = {
+    important?: {
+        title?: string;
+        description?: string;
+    };
+    intro?: string;
+    between?: string;
+    parties?: ContractSection;
+    background?: ContractSection;
+    witnesses?: ContractSection;
+} & Record<`subheader-${number}`, ContractSection | undefined> & Record<string, unknown>;
+/**
+ * The exempt (wholesale) contract renders from the same tree as the retail
+ * one; the templates differ, the SHAPE does not. Kept as its own name because
+ * `contractType` distinguishes them everywhere else.
+ */
+export type ExemptLoanContract = RetailLoanContract;
+/** Either contract, parsed. Both are the same tree. */
+export type LoanContractFormatted = RetailLoanContract;
+/**
+ * `contractType` arrives over the wire as a free string; these are the two the
+ * version byte encodes.
+ */
+export type ContractType = 'retail' | 'exempt';
+export interface GenerateContractResponse {
+    fullName: string;
+    /** The plaintext the lender signs (EIP-191). */
+    contractMessage: string;
+    /** Returned as a JSON-encoded string; parse before rendering. */
+    formattedMessage: string;
+    contractType: ContractType;
+    /** Template version (>= 1). */
+    contractVersion: number;
+    /** ms-epoch; feeds the on-chain `depositData` and the TTL guard. */
+    timestamp: number;
+}
+export type ResolvedContractResponse = GenerateContractResponse & {
+    isValid: boolean;
+};
+/** Narrow the backend's loose `contractType` string to the encoded union. */
+export declare function asContractType(raw: string): ContractType;
+/**
+ * Parse the server's JSON-string `formattedMessage` into a tree. Returns
+ * `null` on parse failure so a renderer can fall back to the plaintext.
+ */
+export declare function parseFormattedMessage(raw: string): LoanContractFormatted | null;
+/**
+ * Pack the contract version and type into the `versionType` word.
+ *
+ * ```
+ * high byte = contract version (>= 1)
+ * low byte  = 0 for retail, 1 for exempt
+ * ```
+ */
+export declare function buildContractVersionType(contractVersion: number, contractType: ContractType): number;
+/**
+ * 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.
+ */
+export declare function encodeDepositData(args: {
+    signature: string;
+    timestamp: number;
+    contractVersion: number;
+    contractType: ContractType;
+}): string;
+/**
+ * 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"`
+ */
+export declare function formatSignTimestampUtc(timestamp: number): string;
+/**
+ * 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.
+ */
+export declare function buildLoanAgreementSignMessage(p: {
+    strategyName: string;
+    region: string;
+    optionName: string;
+    amountLabel: string;
+    timestamp: number;
+}): string;
+/**
+ * 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`.
+ */
+export declare function buildLegacyContractRequestMessage(address: string, timestampMs: number): string;
+/**
+ * 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`.
+ */
+export declare function buildFullNameRequestMessage(address: string, timestampMs: number): string;