@babylonlabs-io/ts-sdk 1.1.0 → 2.0.0

package/dist/tbv/integrations/aave/utils/vaultSplit.d.ts

@@ -1,38 +1,106 @@
 /**
  * Vault Split Utilities for Aave Liquidation Protection
  *
- * BTC vaults are indivisible UTXOs. During liquidation, the protocol seizes
- * whole vaults as a prefix of the borrower's ordered vault list until the
- * target seizure amount is covered. Splitting deposits into 2 optimally-sized
- * vaults (sacrificial + protected) minimizes over-seizure loss.
+ * BTC vaults are indivisible UTXOs. The Babylon Spoke liquidates one whole
+ * vault per call, taking the head of the borrower's ordered vault list.
+ * Splitting a deposit into 2 vaults (sacrificial + protected) lets a
+ * liquidation take the small head vault and leave the rest of the position.
  *
- * The sacrificial vault (index 0) is sized to cover the expected target seizure
- * plus a safety margin. The protected vault (index 1) holds the remainder and
- * survives liquidation.
+ * The sacrificial vault (index 0) is sized so that seizing it at the expected
+ * liquidation health factor lifts the position back to the split target
+ * health factor. The protected vault (index 1) holds the remainder.
  *
- * Seizure formula (from Aave v4 Section 4.2):
+ * Seizure formula:
  * ```
  * liq_penalty = LB × CF
  * debt_to_repay = total_debt × (THF - current_HF) / (THF - liq_penalty)
  * target_seizure = debt_to_repay × LB
  * ```
  */
+/**
+ * Split target health factor: the health factor a two-vault position lands
+ * on after its sacrificial vault is seized. The sacrificial vault is sized so
+ * that seizing it lifts the position back to this value.
+ *
+ * This is a Babylon sizing parameter, not a contract parameter. The Babylon
+ * Spoke sizes each liquidation by the head vault's BTC and never reads the
+ * Aave `LiquidationConfig.targetHealthFactor`, so no contract can supply it.
+ * At 1.08 the sacrificial vault stays smaller than the protected vault for
+ * every collateral factor up to 86%, and after the first liquidation BTC can
+ * fall about 7.4% more before the protected vault is at risk. The risk model
+ * and the decision are recorded in babylon-toolkit#2577.
+ *
+ * Changing this value resizes every new split. A change needs sign-off from
+ * the risk model owner and two code-owner approvals: this file is the
+ * "Multi-vault split transactions" critical path in CLAUDE.md and has its own
+ * entry in .github/CODEOWNERS.
+ */
+export declare const SPLIT_TARGET_HEALTH_FACTOR = 1.08;
+/**
+ * Health factor at which a liquidation is assumed to land, in WAD.
+ *
+ * Aave liquidations settle close to 1.0 (median about 0.997 on Aave V3 over
+ * a year), so the split is sized for 0.99. The liquidation bonus used for
+ * sizing is read from the Spoke's bonus curve at this health factor. Same
+ * ownership and review rules as {@link SPLIT_TARGET_HEALTH_FACTOR}.
+ */
+export declare const EXPECTED_HEALTH_FACTOR_AT_LIQUIDATION_WAD = 990000000000000000n;
+/**
+ * {@link EXPECTED_HEALTH_FACTOR_AT_LIQUIDATION_WAD} as a plain number (0.99),
+ * for the floating-point split formulas.
+ */
+export declare const EXPECTED_HEALTH_FACTOR_AT_LIQUIDATION: number;
+/**
+ * Why the split parameters alone refuse a two-vault split. These are the
+ * verdicts {@link findSplitSizingViolation} can return; it sees only the
+ * parameters, so each one holds at any deposit amount. One of them,
+ * `sacrificial-not-smaller`, is also what {@link computeOptimalSplit} reports
+ * when rounding the seizure up leaves the sacrificial vault not strictly
+ * smaller, so seeing it in an {@link OptimalSplitResult} does not by itself
+ * mean the parameters are bad:
+ * - `target-not-above-expected-hf`: THF ≤ expected HF, so the seizure formula
+ *   has no valid target.
+ * - `target-not-above-liquidation-penalty`: THF ≤ LB × CF, so one liquidation
+ *   takes the whole position.
+ * - `sacrificial-not-smaller`: the sacrificial vault would not be strictly
+ *   smaller than the protected vault.
+ * - `no-seizure-expected`: the seized fraction is zero (for example CF 0), so
+ *   a sacrificial vault would be empty and the split would protect nothing.
+ */
+export type SplitParamsViolation = "target-not-above-expected-hf" | "target-not-above-liquidation-penalty" | "sacrificial-not-smaller" | "no-seizure-expected";
+/**
+ * Why {@link computeOptimalSplit} refuses a split: the parameter verdicts
+ * above, plus one only a deposit amount can reach.
+ * - `below-dust`: the vaults would be below the HTLC dust threshold. A
+ *   non-positive deposit reports this too, but only when the parameters
+ *   themselves allow a split — otherwise the parameter verdict wins.
+ */
+export type SplitSizingViolation = SplitParamsViolation | "below-dust";
+/**
+ * Inputs of the Aave v4 liquidation bonus curve, in their on-chain units.
+ */
+export interface LiquidationBonusCurve {
+    /** `LiquidationConfig.healthFactorForMaxBonus`, WAD. Below 1e18. */
+    healthFactorForMaxBonus: bigint;
+    /** `LiquidationConfig.liquidationBonusFactor`, BPS. At most 10_000. */
+    liquidationBonusFactor: bigint;
+    /** `DynamicReserveConfig.maxLiquidationBonus`, BPS. At least 10_000. */
+    maxLiquidationBonus: bigint;
+}
 /**
  * Parameters for computing the optimal vault split.
  */
 export interface OptimalSplitParams {
     /** Total deposit amount in satoshis */
     totalBtc: bigint;
-    /** Collateral factor (e.g. 0.75 for 75%) */
+    /** Collateral factor (e.g. 0.78 for 78%) */
     CF: number;
-    /** Liquidation bonus (e.g. 1.05 for 5% bonus) */
+    /** Liquidation bonus at the expected health factor (e.g. 1.0504) */
     LB: number;
-    /** Target health factor (e.g. 1.10) */
+    /** Split target health factor (e.g. {@link SPLIT_TARGET_HEALTH_FACTOR}) */
     THF: number;
-    /** Expected health factor at liquidation (e.g. 0.95) */
+    /** Expected health factor at liquidation (e.g. {@link EXPECTED_HEALTH_FACTOR_AT_LIQUIDATION}) */
     expectedHF: number;
-    /** Safety margin multiplier for the sacrificial vault (e.g. 1.05 for 5% buffer) */
-    safetyMargin: number;
 }
 /**
  * Result of the optimal vault split computation.
@@ -44,8 +112,14 @@ export interface OptimalSplitResult {
     protectedVault: bigint;
     /** Fraction of collateral that would be seized (0–1) */
     seizedFraction: number;
-    /** Raw target seizure amount in satoshis (before safety margin) */
+    /** Target seizure amount in satoshis */
     targetSeizureBtc: bigint;
+    /**
+     * Why the split is refused, or null when it is valid. Non-null exactly when
+     * the split is not usable: both vault amounts are then 0n, and null always
+     * means two positive amounts that sum to `totalBtc`.
+     */
+    sizingViolation: SplitSizingViolation | null;
 }
 /**
  * Parameters for computing the minimum deposit required for a split.
@@ -55,9 +129,54 @@ export interface MinDepositForSplitParams {
     minPegin: bigint;
     /** Seized fraction (0–1), from computeOptimalSplit or computeSeizedFraction */
     seizedFraction: number;
-    /** Safety margin multiplier (e.g. 1.05) */
-    safetyMargin: number;
 }
+/**
+ * Compute the Aave v4 liquidation bonus at a health factor.
+ *
+ * Integer-exact port of `LiquidationLogic.calculateLiquidationBonus`
+ * (aave-v4 `src/spoke/libraries/LiquidationLogic.sol`), which the Babylon
+ * liquidation path calls with the same inputs: at or below
+ * `healthFactorForMaxBonus` the bonus is the maximum; above it the bonus falls
+ * linearly towards a minimum of
+ * `(maxLiquidationBonus − 100%) × liquidationBonusFactor + 100%` at HF 1.0.
+ * Every division rounds down, as on-chain.
+ *
+ * @param curve - Bonus curve inputs in on-chain units
+ * @param healthFactorWad - Health factor in WAD, at most 1e18
+ * @returns Liquidation bonus in BPS (e.g. 10504n for 105.04%)
+ * @throws {RangeError} when an input is outside the range the contract
+ *   accepts (the contract would revert or was configured out of range)
+ */
+export declare function computeLiquidationBonusBps(curve: LiquidationBonusCurve, healthFactorWad: bigint): bigint;
+/**
+ * The liquidation bonus a split is sized against: the Spoke's bonus curve at
+ * {@link EXPECTED_HEALTH_FACTOR_AT_LIQUIDATION_WAD}, as a multiplier.
+ *
+ * Every consumer of the split inputs (the deposit split, the liquidation
+ * warnings, the reorder guard, the E2E CLI) must use this one value, or a
+ * fresh split falls short of the seizure the warnings expect.
+ *
+ * @param bonusConfig - `healthFactorForMaxBonus` (WAD) and
+ *   `liquidationBonusFactor` (BPS) from the Spoke's liquidation config
+ * @param maxLiquidationBonusBps - `maxLiquidationBonus` (BPS) of the dynamic
+ *   config the position's liquidation uses
+ * @returns Liquidation bonus multiplier (e.g. 1.0504)
+ * @throws {RangeError} when an input is outside the range the contract accepts
+ */
+export declare function computeSplitLiquidationBonus(bonusConfig: Omit<LiquidationBonusCurve, "maxLiquidationBonus">, maxLiquidationBonusBps: number): number;
+/**
+ * Check the split sizing parameters before a two-vault split is offered.
+ *
+ * @param params - Split target health factor, expected health factor at
+ *   liquidation, collateral factor and liquidation bonus
+ * @returns The first violated rule, or null when a split may be offered
+ */
+export declare function findSplitSizingViolation(params: {
+    CF: number;
+    LB: number;
+    THF: number;
+    expectedHF: number;
+}): SplitParamsViolation | null;
 /**
  * Compute the fraction of collateral that would be seized during liquidation,
  * returning both the raw (unclamped) and clamped values.
@@ -71,10 +190,10 @@ export interface MinDepositForSplitParams {
  * seized_fraction = CF × (THF - expectedHF) / (THF - liq_penalty) × LB / expectedHF
  * ```
  *
- * @param CF - Collateral factor (e.g. 0.75)
- * @param LB - Liquidation bonus (e.g. 1.05)
- * @param THF - Target health factor (e.g. 1.10)
- * @param expectedHF - Expected health factor at liquidation (e.g. 0.95)
+ * @param CF - Collateral factor (e.g. 0.78)
+ * @param LB - Liquidation bonus at the expected health factor (e.g. 1.0504, see {@link computeSplitLiquidationBonus})
+ * @param THF - Split target health factor (e.g. {@link SPLIT_TARGET_HEALTH_FACTOR})
+ * @param expectedHF - Expected health factor at liquidation (e.g. {@link EXPECTED_HEALTH_FACTOR_AT_LIQUIDATION})
  * @returns Both the raw seized fraction and the clamped [0, 1] value
  */
 export declare function computeSeizedFractionDetailed(CF: number, LB: number, THF: number, expectedHF: number): {
@@ -84,36 +203,46 @@ export declare function computeSeizedFractionDetailed(CF: number, LB: number, TH
 /**
  * Compute the fraction of collateral that would be seized during liquidation.
  *
- * @param CF - Collateral factor (e.g. 0.75)
- * @param LB - Liquidation bonus (e.g. 1.05)
- * @param THF - Target health factor (e.g. 1.10)
- * @param expectedHF - Expected health factor at liquidation (e.g. 0.95)
+ * @param CF - Collateral factor (e.g. 0.78)
+ * @param LB - Liquidation bonus at the expected health factor (e.g. 1.0504, see {@link computeSplitLiquidationBonus})
+ * @param THF - Split target health factor (e.g. {@link SPLIT_TARGET_HEALTH_FACTOR})
+ * @param expectedHF - Expected health factor at liquidation (e.g. {@link EXPECTED_HEALTH_FACTOR_AT_LIQUIDATION})
  * @returns Seized fraction clamped to [0, 1]
  */
 export declare function computeSeizedFraction(CF: number, LB: number, THF: number, expectedHF: number): number;
 /**
  * Compute the optimal split between a sacrificial vault and a protected vault.
  *
- * The sacrificial vault (index 0) is sized to cover the target seizure amount
- * plus a safety margin. The protected vault (index 1) holds the remainder.
+ * The sacrificial vault (index 0) is the target seizure rounded up to a whole
+ * satoshi. The protected vault (index 1) holds the remainder. The split is
+ * refused when the parameters fail {@link findSplitSizingViolation}, when
+ * rounding the seizure up leaves the sacrificial vault not strictly smaller,
+ * or when the vaults would be dust — a non-positive deposit reaches the last
+ * of these whenever the parameters themselves allow a split. Both amounts are
+ * then 0n and `sizingViolation` says why; a null violation means two positive
+ * amounts that sum to `totalBtc`.
  *
- * @param params - Split parameters including total BTC, risk params, and safety margin
- * @returns Split result with vault sizes, seized fraction, and target seizure
+ * @param params - Total BTC and split sizing parameters
+ * @returns Split result with vault sizes, seized fraction, target seizure and
+ *   any sizing violation
  *
  * @example
  * ```typescript
- * import { computeOptimalSplit } from "@babylonlabs-io/ts-sdk/tbv/integrations/aave";
+ * import {
+ *   computeOptimalSplit,
+ *   EXPECTED_HEALTH_FACTOR_AT_LIQUIDATION,
+ *   SPLIT_TARGET_HEALTH_FACTOR,
+ * } from "@babylonlabs-io/ts-sdk/tbv/integrations/aave";
  *
  * const result = computeOptimalSplit({
  *   totalBtc: 1_000_000_000n, // 10 BTC in sats
- *   CF: 0.75,
- *   LB: 1.05,
- *   THF: 1.10,
- *   expectedHF: 0.95,
- *   safetyMargin: 1.05,
+ *   CF: 0.78,
+ *   LB: 1.0504,
+ *   THF: SPLIT_TARGET_HEALTH_FACTOR,
+ *   expectedHF: EXPECTED_HEALTH_FACTOR_AT_LIQUIDATION,
  * });
- * // result.sacrificialVault ≈ 418_000_000n (4.18 BTC)
- * // result.protectedVault ≈ 582_000_000n (5.82 BTC)
+ * // result.sacrificialVault === 285_716_677n (2.86 BTC)
+ * // result.protectedVault === 714_283_323n (7.14 BTC)
  * ```
  */
 export declare function computeOptimalSplit(params: OptimalSplitParams): OptimalSplitResult;
@@ -124,9 +253,10 @@ export declare function computeOptimalSplit(params: OptimalSplitParams): Optimal
  * the minimum total deposit where both the sacrificial and protected vaults
  * would meet the minimum peg-in requirement.
  *
- * @param params - Parameters including minimum peg-in, seized fraction, and safety margin
+ * @param params - Minimum peg-in and seized fraction
  * @returns Minimum total deposit in satoshis. Returns 0n in two cases:
- *   - `seizedFraction * safetyMargin >= 1`: split impossible (sacrificial vault would consume entire deposit)
+ *   - `seizedFraction >= 0.5`: split refused (the sacrificial vault would not
+ *     be smaller than the protected vault)
  *   - `seizedFraction <= 0`: split not useful (no seizure expected at this health factor)
  *
  * @example
@@ -135,9 +265,9 @@ export declare function computeOptimalSplit(params: OptimalSplitParams): Optimal
  *
  * const minDeposit = computeMinDepositForSplit({
  *   minPegin: 50_000n, // 0.0005 BTC
- *   seizedFraction: 0.398,
- *   safetyMargin: 1.05,
+ *   seizedFraction: 0.2857,
  * });
+ * // minDeposit === 175_009n: 50_000 / 0.2857, rounded up
  * ```
  */
 export declare function computeMinDepositForSplit(params: MinDepositForSplitParams): bigint;

package/dist/tbv/integrations/aave/utils/vaultSplit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vaultSplit.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/integrations/aave/utils/vaultSplit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAsBH;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,uCAAuC;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,4CAA4C;IAC5C,EAAE,EAAE,MAAM,CAAC;IACX,iDAAiD;IACjD,EAAE,EAAE,MAAM,CAAC;IACX,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,wDAAwD;IACxD,UAAU,EAAE,MAAM,CAAC;IACnB,mFAAmF;IACnF,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,mEAAmE;IACnE,gBAAgB,EAAE,MAAM,CAAC;IACzB,yEAAyE;IACzE,cAAc,EAAE,MAAM,CAAC;IACvB,wDAAwD;IACxD,cAAc,EAAE,MAAM,CAAC;IACvB,mEAAmE;IACnE,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,wCAAwC;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,+EAA+E;IAC/E,cAAc,EAAE,MAAM,CAAC;IACvB,2CAA2C;IAC3C,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,6BAA6B,CAC3C,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,GACjB;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,iBAAiB,EAAE,MAAM,CAAA;CAAE,CAsBvD;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,GACjB,MAAM,CAER;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,kBAAkB,GACzB,kBAAkB,CAkDpB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,wBAAwB,GAC/B,MAAM,CAyBR"}
+{"version":3,"file":"vaultSplit.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/integrations/aave/utils/vaultSplit.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babylonlabs-io/ts-sdk",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -143,7 +143,6 @@
     }
   },
   "devDependencies": {
-    "@babylonlabs-io/babylon-tbv-rust-wasm": "1.1.0",
     "@vitest/browser-playwright": "4.0.9",
     "@vitest/coverage-v8": "^4.0.8",
     "@vitest/ui": "^4.0.8",
@@ -159,6 +158,7 @@
     "vite": "^6.4.1",
     "vite-plugin-dts": "^4.3.0",
     "vitest": "4.0.9",
+    "@babylonlabs-io/babylon-tbv-rust-wasm": "1.1.0",
     "@internal/eslint-config": "0.0.0"
   },
   "publishConfig": {