@babylonlabs-io/ts-sdk 0.0.0-semantic-release.2 → 0.1.0

package/dist/tbv/integrations/aave/types.d.ts

@@ -0,0 +1,66 @@
+import { Address, Hex } from 'viem';
+/**
+ * Depositor structure from contract
+ */
+export interface DepositorStruct {
+    ethAddress: Address;
+    btcPubKey: Hex;
+}
+/**
+ * Aave position structure from the contract.
+ * The controller resolves the user's proxy and vaults from their address.
+ */
+export interface AaveMarketPosition {
+    proxyContract: Address;
+    vaultIds: Hex[];
+}
+/**
+ * User account data from the Spoke
+ * Contains aggregated position health data calculated by Aave using on-chain oracle prices.
+ */
+export interface AaveSpokeUserAccountData {
+    /** Risk premium */
+    riskPremium: bigint;
+    /** Weighted average collateral factor in WAD (1e18 = 100%) */
+    avgCollateralFactor: bigint;
+    /** Health factor in WAD (1e18 = 1.00) */
+    healthFactor: bigint;
+    /** Total collateral value in base currency (1e26 = $1 USD) */
+    totalCollateralValue: bigint;
+    /** Total debt value in base currency (1e26 = $1 USD) */
+    totalDebtValue: bigint;
+    /** Number of active collateral reserves */
+    activeCollateralCount: bigint;
+    /** Number of borrowed reserves */
+    borrowedCount: bigint;
+}
+/**
+ * User position data from the Spoke
+ */
+export interface AaveSpokeUserPosition {
+    /** Drawn debt shares */
+    drawnShares: bigint;
+    /** Premium shares (interest) */
+    premiumShares: bigint;
+    /** Realized premium (ray) */
+    realizedPremiumRay: bigint;
+    /** Premium offset (ray) */
+    premiumOffsetRay: bigint;
+    /** Supplied collateral shares */
+    suppliedShares: bigint;
+    /** Dynamic config key */
+    dynamicConfigKey: number;
+}
+/**
+ * Transaction parameters for unsigned transactions
+ * Compatible with viem's transaction format
+ */
+export interface TransactionParams {
+    /** Contract address to call */
+    to: Address;
+    /** Encoded function data */
+    data: Hex;
+    /** Value to send (optional, defaults to 0) */
+    value?: bigint;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/tbv/integrations/aave/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/tbv/integrations/aave/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAEzC;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,GAAG,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,OAAO,CAAC;IACvB,QAAQ,EAAE,GAAG,EAAE,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACvC,mBAAmB;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,8DAA8D;IAC9D,mBAAmB,EAAE,MAAM,CAAC;IAC5B,yCAAyC;IACzC,YAAY,EAAE,MAAM,CAAC;IACrB,8DAA8D;IAC9D,oBAAoB,EAAE,MAAM,CAAC;IAC7B,wDAAwD;IACxD,cAAc,EAAE,MAAM,CAAC;IACvB,2CAA2C;IAC3C,qBAAqB,EAAE,MAAM,CAAC;IAC9B,kCAAkC;IAClC,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,wBAAwB;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,gCAAgC;IAChC,aAAa,EAAE,MAAM,CAAC;IACtB,6BAA6B;IAC7B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,2BAA2B;IAC3B,gBAAgB,EAAE,MAAM,CAAC;IACzB,iCAAiC;IACjC,cAAc,EAAE,MAAM,CAAC;IACvB,yBAAyB;IACzB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,+BAA+B;IAC/B,EAAE,EAAE,OAAO,CAAC;IACZ,4BAA4B;IAC5B,IAAI,EAAE,GAAG,CAAC;IACV,8CAA8C;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB"}

package/dist/tbv/integrations/aave/utils/__tests__/aaveConversions.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for Aave value conversion utilities
+ */
+export {};
+//# sourceMappingURL=aaveConversions.test.d.ts.map

package/dist/tbv/integrations/aave/utils/__tests__/aaveConversions.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aaveConversions.test.d.ts","sourceRoot":"","sources":["../../../../../../src/tbv/integrations/aave/utils/__tests__/aaveConversions.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/tbv/integrations/aave/utils/__tests__/borrowRatio.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for borrow ratio utilities
+ */
+export {};
+//# sourceMappingURL=borrowRatio.test.d.ts.map

package/dist/tbv/integrations/aave/utils/__tests__/borrowRatio.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"borrowRatio.test.d.ts","sourceRoot":"","sources":["../../../../../../src/tbv/integrations/aave/utils/__tests__/borrowRatio.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/tbv/integrations/aave/utils/__tests__/debtUtils.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for debt utilities
+ */
+export {};
+//# sourceMappingURL=debtUtils.test.d.ts.map

package/dist/tbv/integrations/aave/utils/__tests__/debtUtils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debtUtils.test.d.ts","sourceRoot":"","sources":["../../../../../../src/tbv/integrations/aave/utils/__tests__/debtUtils.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/tbv/integrations/aave/utils/__tests__/healthFactor.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for health factor utilities
+ */
+export {};
+//# sourceMappingURL=healthFactor.test.d.ts.map

package/dist/tbv/integrations/aave/utils/__tests__/healthFactor.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"healthFactor.test.d.ts","sourceRoot":"","sources":["../../../../../../src/tbv/integrations/aave/utils/__tests__/healthFactor.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/tbv/integrations/aave/utils/__tests__/vaultSelection.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=vaultSelection.test.d.ts.map

package/dist/tbv/integrations/aave/utils/__tests__/vaultSelection.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vaultSelection.test.d.ts","sourceRoot":"","sources":["../../../../../../src/tbv/integrations/aave/utils/__tests__/vaultSelection.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,5 @@
+/**
+ * Tests for vault split calculation utilities
+ */
+export {};
+//# sourceMappingURL=vaultSplit.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vaultSplit.test.d.ts","sourceRoot":"","sources":["../../../../../../src/tbv/integrations/aave/utils/__tests__/vaultSplit.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

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

@@ -0,0 +1,24 @@
+/**
+ * Aave Value Conversion Utilities
+ *
+ * Converts Aave on-chain values to human-readable numbers.
+ */
+/**
+ * Convert Aave base currency value to USD
+ *
+ * Aave uses 1e26 = $1 USD for collateral and debt values.
+ *
+ * @param value - Value in Aave base currency (1e26 = $1)
+ * @returns Value in USD
+ */
+export declare function aaveValueToUsd(value: bigint): number;
+/**
+ * Convert Aave WAD value to number
+ *
+ * WAD is used for health factor and collateral factor (1e18 = 1.0).
+ *
+ * @param value - Value in WAD (1e18 = 1.0)
+ * @returns Decimal number
+ */
+export declare function wadToNumber(value: bigint): number;
+//# sourceMappingURL=aaveConversions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aaveConversions.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/integrations/aave/utils/aaveConversions.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEjD"}

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

@@ -0,0 +1,15 @@
+/**
+ * Borrow Ratio Utilities
+ *
+ * Borrow ratio = debt / collateral as a percentage.
+ * Shows how much of the collateral is being used for borrowing.
+ */
+/**
+ * Calculate borrow ratio (debt / collateral) as percentage string
+ *
+ * @param debtUsd - Total debt in USD
+ * @param collateralValueUsd - Total collateral value in USD
+ * @returns Formatted percentage string (e.g., "15.7%")
+ */
+export declare function calculateBorrowRatio(debtUsd: number, collateralValueUsd: number): string;
+//# sourceMappingURL=borrowRatio.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"borrowRatio.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/integrations/aave/utils/borrowRatio.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,kBAAkB,EAAE,MAAM,GACzB,MAAM,CAIR"}

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

@@ -0,0 +1,14 @@
+import { AaveSpokeUserPosition } from '../types.js';
+/**
+ * Check if a position has any debt based on Spoke position data.
+ *
+ * A position is considered to have debt if any of:
+ * - drawnShares > 0 (borrowed principal)
+ * - premiumShares > 0 (accrued interest shares)
+ * - realizedPremiumRay > 0 (realized interest)
+ *
+ * @param position - User position data from Spoke
+ * @returns true if the position has any debt
+ */
+export declare function hasDebtFromPosition(position: AaveSpokeUserPosition): boolean;
+//# sourceMappingURL=debtUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"debtUtils.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/integrations/aave/utils/debtUtils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEzD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,qBAAqB,GAAG,OAAO,CAM5E"}

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

@@ -0,0 +1,108 @@
+/**
+ * Health Factor Utilities for Aave
+ *
+ * Health factor is calculated by Aave on-chain using oracle prices.
+ * A health factor below 1.0 means the position can be liquidated.
+ *
+ * Status thresholds:
+ * - no_debt: No active debt (null health factor)
+ * - danger: < 1.0 (can be liquidated)
+ * - warning: < HEALTH_FACTOR_WARNING_THRESHOLD (at risk)
+ * - safe: >= HEALTH_FACTOR_WARNING_THRESHOLD (healthy)
+ *
+ * Color mapping:
+ * - Green (#00E676): safe
+ * - Amber (#FFC400): warning
+ * - Red (#FF1744): danger
+ * - Gray (#5A5A5A): no_debt
+ */
+export declare const HEALTH_FACTOR_COLORS: {
+    readonly GREEN: "#00E676";
+    readonly AMBER: "#FFC400";
+    readonly RED: "#FF1744";
+    readonly GRAY: "#5A5A5A";
+};
+export type HealthFactorColor = (typeof HEALTH_FACTOR_COLORS)[keyof typeof HEALTH_FACTOR_COLORS];
+/**
+ * Health factor status based on our liquidation threshold
+ */
+export type HealthFactorStatus = "safe" | "warning" | "danger" | "no_debt";
+/**
+ * Determine health factor status for UI display
+ *
+ * @param healthFactor - The health factor as a number (null if no debt)
+ * @param hasDebt - Whether the position has active debt
+ * @returns The status classification
+ */
+export declare function getHealthFactorStatus(healthFactor: number | null, hasDebt: boolean): HealthFactorStatus;
+/**
+ * Gets the appropriate color for a health factor status.
+ *
+ * @param status - The health factor status
+ * @returns The color code for the status
+ */
+export declare function getHealthFactorColor(status: HealthFactorStatus): HealthFactorColor;
+/**
+ * Format health factor number for display
+ *
+ * @param healthFactor - Health factor number (null if no debt)
+ * @returns Formatted string for display
+ */
+export declare function formatHealthFactor(healthFactor: number | null): string;
+/**
+ * Checks if a health factor value represents a healthy position.
+ *
+ * @param healthFactor - The health factor as a number
+ * @returns true if the health factor is >= 1.0 (healthy), false otherwise
+ */
+export declare function isHealthFactorHealthy(healthFactor: number | null): boolean;
+/**
+ * Get health factor status from a numeric value.
+ * Used for UI components that work with Infinity for no-debt scenarios.
+ *
+ * @param value - Health factor value (Infinity when no debt)
+ * @returns The status classification
+ */
+export declare function getHealthFactorStatusFromValue(value: number): HealthFactorStatus;
+/**
+ * Calculate health factor for an AAVE position.
+ *
+ * **Formula:** `HF = (Collateral × Liquidation Threshold) / Total Debt`
+ *
+ * Health factor determines liquidation risk:
+ * - `>= 1.5` - Safe (green)
+ * - `1.0 - 1.5` - Warning (amber)
+ * - `< 1.0` - Danger, position can be liquidated (red)
+ *
+ * @param collateralValueUsd - Total collateral value in USD (as number, not bigint)
+ * @param totalDebtUsd - Total debt value in USD (as number, not bigint)
+ * @param liquidationThresholdBps - Liquidation threshold in basis points (e.g., `8000` = 80%)
+ * @returns Health factor value (e.g., `1.5`), or `Infinity` if no debt
+ *
+ * @example
+ * ```typescript
+ * import { calculateHealthFactor, HEALTH_FACTOR_WARNING_THRESHOLD } from "@babylonlabs-io/ts-sdk/tbv/integrations/aave";
+ *
+ * // User has $10,000 BTC collateral, $5,000 debt, 80% LT
+ * const hf = calculateHealthFactor(10000, 5000, 8000);
+ * // Result: 1.6 (safe to borrow more)
+ *
+ * if (hf < 1.0) {
+ *   console.error("Position can be liquidated!");
+ * } else if (hf < HEALTH_FACTOR_WARNING_THRESHOLD) {
+ *   console.warn("Position at risk, consider repaying");
+ * } else {
+ *   console.log("Position is safe");
+ * }
+ * ```
+ *
+ * @remarks
+ * **Before borrowing:**
+ * Use this to calculate resulting health factor and ensure it stays above safe threshold.
+ *
+ * **Unit conversions:**
+ * - Convert AAVE base currency (1e26) to USD by dividing by 1e26
+ * - Use `aaveValueToUsd()` helper for automatic conversion
+ */
+export declare function calculateHealthFactor(collateralValueUsd: number, totalDebtUsd: number, liquidationThresholdBps: number): number;
+//# sourceMappingURL=healthFactor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"healthFactor.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/integrations/aave/utils/healthFactor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,eAAO,MAAM,oBAAoB;;;;;CAKvB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAC3B,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,OAAO,oBAAoB,CAAC,CAAC;AAEnE;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE3E;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,MAAM,GAAG,IAAI,EAC3B,OAAO,EAAE,OAAO,GACf,kBAAkB,CAMpB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,kBAAkB,GACzB,iBAAiB,CAWnB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAKtE;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAK1E;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,MAAM,GACZ,kBAAkB,CAIpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,qBAAqB,CACnC,kBAAkB,EAAE,MAAM,EAC1B,YAAY,EAAE,MAAM,EACpB,uBAAuB,EAAE,MAAM,GAC9B,MAAM,CAKR"}

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

@@ -0,0 +1,10 @@
+export { aaveValueToUsd, wadToNumber } from './aaveConversions.js';
+export { calculateBorrowRatio } from './borrowRatio.js';
+export { hasDebtFromPosition } from './debtUtils.js';
+export { HEALTH_FACTOR_COLORS, calculateHealthFactor, formatHealthFactor, getHealthFactorColor, getHealthFactorStatus, getHealthFactorStatusFromValue, isHealthFactorHealthy, } from './healthFactor.js';
+export type { HealthFactorColor, HealthFactorStatus } from './healthFactor.js';
+export { calculateTotalVaultAmount, selectVaultsForAmount, } from './vaultSelection.js';
+export type { SelectableVault, VaultSelectionResult, } from './vaultSelection.js';
+export { checkRebalanceNeeded, computeMinDepositForSplit, computeOptimalSplit, computeSeizedFraction, } from './vaultSplit.js';
+export type { MinDepositForSplitParams, OptimalSplitParams, OptimalSplitResult, RebalanceCheckParams, RebalanceCheckResult, } from './vaultSplit.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/integrations/aave/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EACrB,8BAA8B,EAC9B,qBAAqB,GACtB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC/E,OAAO,EACL,yBAAyB,EACzB,qBAAqB,GACtB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACV,eAAe,EACf,oBAAoB,GACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACV,wBAAwB,EACxB,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,iBAAiB,CAAC"}

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

@@ -0,0 +1,33 @@
+/**
+ * Vault Selection Utilities for Aave
+ *
+ * Provides functions for selecting vaults to match a target collateral amount.
+ * Uses a greedy algorithm that prioritizes larger vaults first.
+ */
+export interface SelectableVault {
+    id: string;
+    amount: number;
+}
+export interface VaultSelectionResult {
+    /** IDs of selected vaults */
+    vaultIds: string[];
+    /** Actual total amount from selected vaults */
+    actualAmount: number;
+}
+/**
+ * Select vaults to match the target amount using a greedy algorithm.
+ * Sorts vaults by amount descending and picks until target is met.
+ *
+ * @param vaults - Available vaults to select from
+ * @param targetAmount - Target amount to reach
+ * @returns Selected vault IDs and actual amount
+ */
+export declare function selectVaultsForAmount(vaults: SelectableVault[], targetAmount: number): VaultSelectionResult;
+/**
+ * Calculate total amount from a list of vaults
+ *
+ * @param vaults - Vaults to sum
+ * @returns Total amount in BTC
+ */
+export declare function calculateTotalVaultAmount(vaults: SelectableVault[]): number;
+//# sourceMappingURL=vaultSelection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vaultSelection.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/integrations/aave/utils/vaultSelection.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,oBAAoB;IACnC,6BAA6B;IAC7B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,+CAA+C;IAC/C,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,eAAe,EAAE,EACzB,YAAY,EAAE,MAAM,GACnB,oBAAoB,CAiBtB;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,eAAe,EAAE,GAAG,MAAM,CAE3E"}

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

@@ -0,0 +1,191 @@
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * Seizure formula (from Aave v4 Section 4.2):
+ * ```
+ * liq_penalty = LB × CF
+ * debt_to_repay = total_debt × (THF - current_HF) / (THF - liq_penalty)
+ * target_seizure = debt_to_repay × LB
+ * ```
+ */
+/**
+ * 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%) */
+    CF: number;
+    /** Liquidation bonus (e.g. 1.05 for 5% bonus) */
+    LB: number;
+    /** Target health factor (e.g. 1.10) */
+    THF: number;
+    /** Expected health factor at liquidation (e.g. 0.95) */
+    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.
+ */
+export interface OptimalSplitResult {
+    /** Sacrificial vault amount in satoshis (index 0, seized first) */
+    sacrificialVault: bigint;
+    /** Protected vault amount in satoshis (index 1, survives liquidation) */
+    protectedVault: bigint;
+    /** Fraction of collateral that would be seized (0–1) */
+    seizedFraction: number;
+    /** Raw target seizure amount in satoshis (before safety margin) */
+    targetSeizureBtc: bigint;
+}
+/**
+ * Parameters for computing the minimum deposit required for a split.
+ */
+export interface MinDepositForSplitParams {
+    /** Minimum peg-in amount in satoshis */
+    minPegin: bigint;
+    /** Seized fraction (0–1), from computeOptimalSplit or computeSeizedFraction */
+    seizedFraction: number;
+    /** Safety margin multiplier (e.g. 1.05) */
+    safetyMargin: number;
+}
+/**
+ * Parameters for checking if a vault rebalance is needed.
+ */
+export interface RebalanceCheckParams {
+    /** Ordered vault amounts in satoshis (index 0 is sacrificial) */
+    vaultAmounts: bigint[];
+    /** Collateral factor (e.g. 0.75) */
+    CF: number;
+    /** Liquidation bonus (e.g. 1.05) */
+    LB: number;
+    /** Target health factor (e.g. 1.10) */
+    THF: number;
+    /** Expected health factor at liquidation (e.g. 0.95) */
+    expectedHF: number;
+    /** Safety margin multiplier (e.g. 1.05) */
+    safetyMargin: number;
+}
+/**
+ * Result of a vault rebalance check.
+ */
+export interface RebalanceCheckResult {
+    /** Whether the sacrificial vault needs to be increased */
+    needsRebalance: boolean;
+    /** How much more the sacrificial vault needs in satoshis (0n if no rebalance needed) */
+    deficit: bigint;
+    /** Current sacrificial vault coverage in satoshis */
+    currentCoverage: bigint;
+    /** Required sacrificial vault coverage in satoshis */
+    targetCoverage: bigint;
+}
+/**
+ * Compute the fraction of collateral that would be seized during liquidation.
+ *
+ * Formula:
+ * ```
+ * liq_penalty = LB × CF
+ * 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)
+ * @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.
+ *
+ * @param params - Split parameters including total BTC, risk params, and safety margin
+ * @returns Split result with vault sizes, seized fraction, and target seizure
+ *
+ * @example
+ * ```typescript
+ * import { computeOptimalSplit } 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,
+ * });
+ * // result.sacrificialVault ≈ 418_000_000n (4.18 BTC)
+ * // result.protectedVault ≈ 582_000_000n (5.82 BTC)
+ * ```
+ */
+export declare function computeOptimalSplit(params: OptimalSplitParams): OptimalSplitResult;
+/**
+ * Compute the minimum total deposit required for a 2-vault split.
+ *
+ * Both vaults must be at least `minPegin` satoshis. This function returns
+ * 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
+ * @returns Minimum total deposit in satoshis. Returns 0n in two cases:
+ *   - `seizedFraction * safetyMargin >= 1`: split impossible (sacrificial vault would consume entire deposit)
+ *   - `seizedFraction <= 0`: split not useful (no seizure expected at this health factor)
+ *
+ * @example
+ * ```typescript
+ * import { computeMinDepositForSplit } from "@babylonlabs-io/ts-sdk/tbv/integrations/aave";
+ *
+ * const minDeposit = computeMinDepositForSplit({
+ *   minPegin: 50_000n, // 0.0005 BTC
+ *   seizedFraction: 0.398,
+ *   safetyMargin: 1.05,
+ * });
+ * ```
+ */
+export declare function computeMinDepositForSplit(params: MinDepositForSplitParams): bigint;
+/**
+ * Check if the sacrificial vault (index 0) needs to be increased to cover
+ * the current target seizure amount.
+ *
+ * **Scope:** This function only checks whether the sacrificial vault's sizing
+ * is adequate. It does NOT detect whether a split exists — a single vault that
+ * exceeds the target coverage returns `needsRebalance: false`. Callers should
+ * check `vaultAmounts.length < 2` separately to detect unsplit positions.
+ *
+ * Used on position page load to detect when parameter changes (THF, CF, LB)
+ * have made the current split insufficient.
+ *
+ * @param params - Current vault amounts and risk parameters
+ * @returns Whether rebalance is needed, with deficit details
+ *
+ * @example
+ * ```typescript
+ * import { checkRebalanceNeeded } from "@babylonlabs-io/ts-sdk/tbv/integrations/aave";
+ *
+ * const result = checkRebalanceNeeded({
+ *   vaultAmounts: [300_000_000n, 700_000_000n], // 3 BTC sacrificial, 7 BTC protected
+ *   CF: 0.75,
+ *   LB: 1.05,
+ *   THF: 1.10,
+ *   expectedHF: 0.95,
+ *   safetyMargin: 1.05,
+ * });
+ *
+ * if (result.needsRebalance) {
+ *   console.log(`Sacrificial vault needs ${result.deficit} more sats`);
+ * }
+ * ```
+ */
+export declare function checkRebalanceNeeded(params: RebalanceCheckParams): RebalanceCheckResult;
+//# sourceMappingURL=vaultSplit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vaultSplit.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/integrations/aave/utils/vaultSplit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAYH;;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;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,iEAAiE;IACjE,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,oCAAoC;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,oCAAoC;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,wDAAwD;IACxD,UAAU,EAAE,MAAM,CAAC;IACnB,2CAA2C;IAC3C,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,0DAA0D;IAC1D,cAAc,EAAE,OAAO,CAAC;IACxB,wFAAwF;IACxF,OAAO,EAAE,MAAM,CAAC;IAChB,qDAAqD;IACrD,eAAe,EAAE,MAAM,CAAC;IACxB,sDAAsD;IACtD,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,GACjB,MAAM,CAmBR;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,kBAAkB,GACzB,kBAAkB,CAgCpB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,wBAAwB,GAC/B,MAAM,CAyBR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,oBAAoB,GAC3B,oBAAoB,CA+BtB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babylonlabs-io/ts-sdk",
-  "version": "0.0.0-semantic-release.2",
+  "version": "0.1.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,10 +20,20 @@
       "require": "./dist/tbv/core/index.cjs",
       "import": "./dist/tbv/core/index.js"
     },
-    "./tbv/integrations/morpho": {
-      "types": "./dist/tbv/integrations/morpho/index.d.ts",
-      "require": "./dist/tbv/integrations/morpho/index.cjs",
-      "import": "./dist/tbv/integrations/morpho/index.js"
+    "./tbv/core/primitives": {
+      "types": "./dist/tbv/core/primitives/index.d.ts",
+      "require": "./dist/tbv/core/primitives/index.cjs",
+      "import": "./dist/tbv/core/primitives/index.js"
+    },
+    "./tbv/core/utils": {
+      "types": "./dist/tbv/core/utils/index.d.ts",
+      "require": "./dist/tbv/core/utils/index.cjs",
+      "import": "./dist/tbv/core/utils/index.js"
+    },
+    "./tbv/integrations/aave": {
+      "types": "./dist/tbv/integrations/aave/index.d.ts",
+      "require": "./dist/tbv/integrations/aave/index.cjs",
+      "import": "./dist/tbv/integrations/aave/index.js"
     },
     "./shared": {
       "types": "./dist/shared/index.d.ts",
@@ -51,27 +61,47 @@
   "author": "",
   "license": "ISC",
   "description": "TypeScript SDK for Babylon protocol integrations",
+  "dependencies": {
+    "@bitcoin-js/tiny-secp256k1-asmjs": "2.2.3",
+    "bitcoinjs-lib": "6.1.7",
+    "buffer": "6.0.3",
+    "@babylonlabs-io/babylon-tbv-rust-wasm": "0.1.0"
+  },
+  "peerDependencies": {
+    "viem": "^2.38.2"
+  },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.0.8",
     "@vitest/ui": "^4.0.8",
+    "eslint-plugin-jsdoc": "^50.6.17",
+    "eslint-plugin-tsdoc": "^0.4.0",
     "prettier": "^3.6.2",
     "prettier-plugin-organize-imports": "^4.1.0",
+    "typedoc": "^0.28.5",
+    "typedoc-plugin-markdown": "^4.6.3",
     "typescript": "^5.8.3",
+    "viem": "^2.38.2",
     "vite": "^6.4.1",
     "vite-plugin-dts": "^4.3.0",
     "vitest": "^4.0.8",
     "@internal/eslint-config": "0.0.0"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "scripts": {
     "build": "tsc -b --noEmit tsconfig.lib.json && vite build",
     "format": "prettier --check \"src/**/*.ts\"",
     "format:fix": "prettier --write \"src/**/*.ts\"",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:ui": "vitest --ui",
-    "test:coverage": "vitest run --coverage"
+    "test:coverage": "vitest run --coverage",
+    "docs:generate": "typedoc",
+    "docs:clean": "rm -rf docs/api && pnpm docs:generate",
+    "docs:validate": "typedoc --emit none"
   }
 }

package/dist/shared/__tests__/example.test.d.ts

@@ -1,6 +0,0 @@
-/**
- * Example test file demonstrating test patterns
- * This demonstrates how to structure tests in the SDK
- */
-export {};
-//# sourceMappingURL=example.test.d.ts.map