Cap predict NAV index sizes

Author: 0xaslan

packages/predict/sources/constants.move

@@ -69,6 +69,12 @@ public(package) macro fun max_plp_price(): u64 { 100_000_000_000 }
 /// full-pool flush.
 public(package) macro fun max_live_expiry_markets(): u64 { 24 }
 
+/// Maximum finite payout-tree boundary nodes one expiry market may carry into NAV.
+public(package) macro fun max_payout_tree_nodes(): u64 { 1_000 }
+
+/// Maximum active leveraged orders one expiry market may carry into NAV.
+public(package) macro fun max_active_leveraged_orders(): u64 { 5_000 }
+
 // === Time Constants ===
 
 /// Milliseconds in one minute.

packages/predict/sources/strike_exposure/index/liquidation_book.move

@@ -22,6 +22,7 @@ const EActiveOrderAlreadyExists: u64 = 0;
 const EActiveOrderNotFound: u64 = 1;
 const ELiquidatedOrderAlreadyExists: u64 = 2;
 const ELiquidatedOrderNotFound: u64 = 3;
+const EMaxActiveLeveragedOrders: u64 = 4;
 
 const PAGE_CAPACITY: u64 = 64;
 
@@ -135,6 +136,10 @@ public(package) fun insert_order(book: &mut LiquidationBook, order: &Order) {
 
     let order_id = order.id();
     assert!(!book.liquidated_orders.contains(order_id), ELiquidatedOrderAlreadyExists);
+    assert!(
+        book.active_order_count < constants::max_active_leveraged_orders!(),
+        EMaxActiveLeveragedOrders,
+    );
     book.insert_active_order_id(order_id);
 }
 

packages/predict/sources/strike_exposure/index/strike_payout_tree.move

@@ -20,11 +20,13 @@ use fixed_math::math;
 use sui::{bcs, hash::blake2b256, table::{Self, Table}};
 
 const EInsufficientPayoutTerms: u64 = 0;
+const EMaxPayoutTreeNodes: u64 = 1;
 
 /// Sparse payout-liability tree keyed by finite strike tick.
 public struct StrikePayoutTree has store {
     root: Option<u64>,
     nodes: Table<u64, PayoutNode>,
+    node_count: u64,
     base: PayoutTerms,
 }
 
@@ -138,6 +140,7 @@ public(package) fun new(ctx: &mut TxContext): StrikePayoutTree {
     StrikePayoutTree {
         root: option::none(),
         nodes: table::new(ctx),
+        node_count: 0,
         base: payout_terms(0, 0),
     }
 }
@@ -150,12 +153,27 @@ public(package) fun insert_range(
     quantity: u64,
     floor_shares: u64,
 ) {
-    tree.apply_range(
-        lower_tick,
-        higher_tick,
-        payout_terms(quantity, floor_shares),
-        true,
+    let terms = payout_terms(quantity, floor_shares);
+    if (terms.quantity == 0 && terms.floor_shares == 0) return;
+
+    let mut new_nodes = 0;
+    if (lower_tick != 0 && !tree.nodes.contains(lower_tick)) {
+        new_nodes = new_nodes + 1;
+    };
+    if (
+        higher_tick != constants::pos_inf_tick!()
+            && higher_tick != lower_tick
+            && !tree.nodes.contains(higher_tick)
+    ) {
+        new_nodes = new_nodes + 1;
+    };
+
+    assert!(
+        tree.node_count + new_nodes <= constants::max_payout_tree_nodes!(),
+        EMaxPayoutTreeNodes,
     );
+
+    tree.apply_range(lower_tick, higher_tick, terms, true);
 }
 
 /// Remove interval payout terms for the order tick range `(lower_tick, higher_tick]`.
@@ -181,7 +199,12 @@ public(package) fun debug_contains_node(tree: &StrikePayoutTree, tick: u64): boo
 
 #[test_only]
 public(package) fun debug_node_count(tree: &StrikePayoutTree): u64 {
-    debug_node_count_subtree(&tree.nodes, tree.root)
+    tree.node_count
+}
+
+#[test_only]
+public(package) fun debug_set_node_count(tree: &mut StrikePayoutTree, node_count: u64) {
+    tree.node_count = node_count;
 }
 
 fun apply_range(
@@ -212,6 +235,7 @@ fun apply_boundary_delta(
     is_start: bool,
     add: bool,
 ) {
+    let had_node = tree.nodes.contains(tick);
     let new_root = apply_at(
         &mut tree.nodes,
         tree.root,
@@ -221,6 +245,13 @@ fun apply_boundary_delta(
         add,
     );
     tree.root = new_root;
+
+    let has_node = tree.nodes.contains(tick);
+    if (!had_node && has_node) {
+        tree.node_count = tree.node_count + 1;
+    } else if (had_node && !has_node) {
+        tree.node_count = tree.node_count - 1;
+    };
 }
 
 fun apply_at(
@@ -548,16 +579,6 @@ fun is_empty_node(node: PayoutNode): bool {
     is_zero_terms(node.local_start) && is_zero_terms(node.local_end)
 }
 
-#[test_only]
-fun debug_node_count_subtree(nodes: &Table<u64, PayoutNode>, root: Option<u64>): u64 {
-    if (root.is_none()) return 0;
-    let tick = *root.borrow();
-    let node = nodes[tick];
-    1
-        + debug_node_count_subtree(nodes, node.left)
-        + debug_node_count_subtree(nodes, node.right)
-}
-
 fun apply_terms_delta(value: &mut PayoutTerms, delta: PayoutTerms, add: bool) {
     if (add) {
         value.quantity = value.quantity + delta.quantity;

packages/predict/tests/strike_exposure/index/liquidation_book_tests.move

@@ -116,6 +116,47 @@ fun mark_liquidated_removes_active_and_records_tombstone() {
     destroy(book);
 }
 
+#[test, expected_failure(abort_code = liquidation_book::EMaxActiveLeveragedOrders)]
+fun insert_above_active_leveraged_order_cap_aborts() {
+    let ctx = &mut tx_context::dummy();
+    let mut book = liquidation_book::new(ctx);
+    insert_sequential_orders(&mut book, constants::max_active_leveraged_orders!());
+
+    book.insert_order(&leveraged_order_with_sequence(constants::max_active_leveraged_orders!()));
+    abort 999
+}
+
+#[test]
+fun one_x_orders_do_not_count_toward_active_leveraged_order_cap() {
+    let ctx = &mut tx_context::dummy();
+    let mut book = liquidation_book::new(ctx);
+    insert_sequential_orders(&mut book, constants::max_active_leveraged_orders!());
+
+    let one_x = one_x_order_with_sequence(constants::max_active_leveraged_orders!());
+    book.insert_order(&one_x);
+
+    assert!(!book.contains_active_order(&one_x));
+    let candidates = book.select_liquidation_candidates(constants::max_active_leveraged_orders!());
+    assert_eq!(candidates.length(), constants::max_active_leveraged_orders!());
+    destroy(book);
+}
+
+#[test]
+fun removing_active_leveraged_order_frees_cap_slot() {
+    let ctx = &mut tx_context::dummy();
+    let mut book = liquidation_book::new(ctx);
+    insert_sequential_orders(&mut book, constants::max_active_leveraged_orders!());
+
+    let removed = leveraged_order_with_sequence(0);
+    book.remove_order(&removed);
+    let replacement = leveraged_order_with_sequence(constants::max_active_leveraged_orders!());
+    book.insert_order(&replacement);
+
+    assert!(!book.contains_active_order(&removed));
+    assert!(book.contains_active_order(&replacement));
+    destroy(book);
+}
+
 #[test]
 fun head_candidate_prefers_higher_floor_for_equal_quantity() {
     let ctx = &mut tx_context::dummy();
@@ -233,6 +274,16 @@ fun leveraged_order_with_sequence(sequence: u64): Order {
     )
 }
 
+fun one_x_order_with_sequence(sequence: u64): Order {
+    order::new_from_ticks(
+        LOWER_TICK,
+        HIGHER_TICK,
+        0,
+        constants::position_lot_size!(),
+        sequence,
+    )
+}
+
 fun insert_sequential_orders(
     book: &mut liquidation_book::LiquidationBook,
     count: u64,

packages/predict/tests/strike_exposure/index/strike_payout_tree_tests.move

@@ -255,6 +255,64 @@ fun insert_with_both_terms_zero_is_no_op() {
     destroy(tree);
 }
 
+#[test, expected_failure(abort_code = strike_payout_tree::EMaxPayoutTreeNodes)]
+fun insert_new_boundary_above_node_cap_aborts() {
+    let ctx = &mut tx_context::dummy();
+    let mut tree = new_tree(ctx);
+    seed_single_boundary_at_node_cap(&mut tree);
+
+    insert_range(
+        &mut tree,
+        2,
+        constants::pos_inf_tick!(),
+        1,
+        0,
+    );
+    abort 999
+}
+
+#[test, expected_failure(abort_code = strike_payout_tree::EMaxPayoutTreeNodes)]
+fun insert_finite_range_requiring_two_new_boundaries_above_node_cap_aborts() {
+    let ctx = &mut tx_context::dummy();
+    let mut tree = new_tree(ctx);
+    seed_single_boundary_one_slot_below_node_cap(&mut tree);
+
+    insert_range(&mut tree, 2, 3, 1, 0);
+    abort 999
+}
+
+#[test]
+fun insert_existing_boundary_at_node_cap_succeeds() {
+    let ctx = &mut tx_context::dummy();
+    let mut tree = new_tree(ctx);
+    seed_single_boundary_at_node_cap(&mut tree);
+
+    insert_range(&mut tree, 1, constants::pos_inf_tick!(), 1, 0);
+
+    assert_eq!(tree.debug_node_count(), constants::max_payout_tree_nodes!());
+    destroy(tree);
+}
+
+#[test]
+fun removing_boundary_below_node_cap_allows_new_boundary() {
+    let ctx = &mut tx_context::dummy();
+    let mut tree = new_tree(ctx);
+    seed_single_boundary_at_node_cap(&mut tree);
+
+    remove_range(&mut tree, 1, constants::pos_inf_tick!(), 1, 0);
+    assert_eq!(tree.debug_node_count(), constants::max_payout_tree_nodes!() - 1);
+
+    insert_range(
+        &mut tree,
+        2,
+        constants::pos_inf_tick!(),
+        1,
+        0,
+    );
+    assert_eq!(tree.debug_node_count(), constants::max_payout_tree_nodes!());
+    destroy(tree);
+}
+
 // === remove_range ===
 
 #[test]
@@ -423,3 +481,13 @@ fun settled_liability_nets_floor_shares() {
     assert_reserve_terms(&tree, 30, 30);
     destroy(tree);
 }
+
+fun seed_single_boundary_at_node_cap(tree: &mut StrikePayoutTree) {
+    insert_range(tree, 1, constants::pos_inf_tick!(), 1, 0);
+    tree.debug_set_node_count(constants::max_payout_tree_nodes!());
+}
+
+fun seed_single_boundary_one_slot_below_node_cap(tree: &mut StrikePayoutTree) {
+    insert_range(tree, 1, constants::pos_inf_tick!(), 1, 0);
+    tree.debug_set_node_count(constants::max_payout_tree_nodes!() - 1);
+}