Prune settled payout tree nodes

Author: 0xaslan

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

@@ -174,6 +174,16 @@ public(package) fun remove_range(
     );
 }
 
+#[test_only]
+public(package) fun debug_contains_node(tree: &StrikePayoutTree, tick: u64): bool {
+    tree.nodes.contains(tick)
+}
+
+#[test_only]
+public(package) fun debug_node_count(tree: &StrikePayoutTree): u64 {
+    debug_node_count_subtree(&tree.nodes, tree.root)
+}
+
 fun apply_range(
     tree: &mut StrikePayoutTree,
     lower_tick: u64,
@@ -210,7 +220,7 @@ fun apply_boundary_delta(
         is_start,
         add,
     );
-    tree.root = option::some(new_root);
+    tree.root = new_root;
 }
 
 fun apply_at(
@@ -220,12 +230,12 @@ fun apply_at(
     terms: PayoutTerms,
     is_start: bool,
     add: bool,
-): u64 {
+): Option<u64> {
     if (root.is_none()) {
         assert!(add, EInsufficientPayoutTerms);
         let leaf = new_leaf(tick, terms, is_start);
         nodes.add(tick, leaf);
-        return tick
+        return option::some(tick)
     };
 
     let root_tick = *root.borrow();
@@ -237,8 +247,12 @@ fun apply_at(
         } else {
             apply_terms_delta(&mut node.local_end, terms, add);
         };
+        if (is_empty_node(node)) {
+            let _removed = nodes.remove(root_tick);
+            return merge_subtrees(nodes, node.left, node.right)
+        };
         resummarize(nodes, root_tick, node);
-        return root_tick
+        return option::some(root_tick)
     };
 
     if (tick < root_tick) {
@@ -250,11 +264,15 @@ fun apply_at(
             is_start,
             add,
         );
-        let left_node = nodes[new_left];
-        if (left_node.priority > node.priority) {
-            return rotate_right(nodes, root_tick, node, new_left, left_node)
+        if (add && new_left.is_some()) {
+            let left_tick = *new_left.borrow();
+            let left_node = nodes[left_tick];
+            if (left_node.priority > node.priority) {
+                let rotated = rotate_right(nodes, root_tick, node, left_tick, left_node);
+                return option::some(rotated)
+            };
         };
-        node.left = option::some(new_left);
+        node.left = new_left;
     } else {
         let new_right = apply_at(
             nodes,
@@ -264,15 +282,19 @@ fun apply_at(
             is_start,
             add,
         );
-        let right_node = nodes[new_right];
-        if (right_node.priority > node.priority) {
-            return rotate_left(nodes, root_tick, node, new_right, right_node)
+        if (add && new_right.is_some()) {
+            let right_tick = *new_right.borrow();
+            let right_node = nodes[right_tick];
+            if (right_node.priority > node.priority) {
+                let rotated = rotate_left(nodes, root_tick, node, right_tick, right_node);
+                return option::some(rotated)
+            };
         };
-        node.right = option::some(new_right);
+        node.right = new_right;
     };
 
     resummarize(nodes, root_tick, node);
-    root_tick
+    option::some(root_tick)
 }
 
 fun new_leaf(tick: u64, terms: PayoutTerms, is_start: bool): PayoutNode {
@@ -327,6 +349,29 @@ fun rotate_left(
     right_tick
 }
 
+fun merge_subtrees(
+    nodes: &mut Table<u64, PayoutNode>,
+    left: Option<u64>,
+    right: Option<u64>,
+): Option<u64> {
+    if (left.is_none()) return right;
+    if (right.is_none()) return left;
+
+    let left_tick = *left.borrow();
+    let right_tick = *right.borrow();
+    let mut left_node = nodes[left_tick];
+    let mut right_node = nodes[right_tick];
+    if (left_node.priority > right_node.priority) {
+        left_node.right = merge_subtrees(nodes, left_node.right, right);
+        resummarize(nodes, left_tick, left_node);
+        option::some(left_tick)
+    } else {
+        right_node.left = merge_subtrees(nodes, left, right_node.left);
+        resummarize(nodes, right_tick, right_node);
+        option::some(right_tick)
+    }
+}
+
 fun settlement_prefix_terms(
     nodes: &Table<u64, PayoutNode>,
     root: Option<u64>,
@@ -362,8 +407,7 @@ fun settlement_prefix_terms(
 /// Two collapses keep the eval count down:
 /// - skip-zero-delta: when `local_start.quantity == local_end.quantity` the two
 ///   sides contribute the same `P·q` and cancel in `walk_linear`'s top-level
-///   subtraction, so the `up_price` eval is skipped (exact; also drops the
-///   fully-redeemed boundaries the treap never GCs).
+///   subtraction, so the `up_price` eval is skipped (exact).
 /// - bounded interpolation, only when `tolerance > 0`: if the subtree's exact
 ///   price span (`up_price(min_tick·ts) - up_price(max_tick·ts)`, monotone so
 ///   non-negative) is within `tolerance`, the whole subtree is priced at the
@@ -496,6 +540,24 @@ fun payout_terms(quantity: u64, floor_shares: u64): PayoutTerms {
     PayoutTerms { quantity, floor_shares }
 }
 
+fun is_zero_terms(terms: PayoutTerms): bool {
+    terms.quantity == 0 && terms.floor_shares == 0
+}
+
+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/payout_tree_walk_tests.move

@@ -5,9 +5,9 @@
 /// driven by a real live `Pricer` over standalone trees. These exercise paths
 /// `current_nav` cannot reach directly: the bounded-interpolation gate (the
 /// production `nav_interpolation_price_tolerance` is 0, so `current_nav` always
-/// walks exactly), the skip-zero-delta path over a dead (fully-removed) boundary
-/// that the treap never garbage-collects, and the boundary-aggregation dust clamp
-/// — the flat-price-tail integer underflow the ATM `current_nav` fixtures miss.
+/// walks exactly), the skip-zero-delta path over an equal live start/end
+/// boundary, and the boundary-aggregation dust clamp — the flat-price-tail integer
+/// underflow the ATM `current_nav` fixtures miss.
 ///
 /// The tree keys boundaries by absolute tick; the walk recovers each raw strike as
 /// `tick * tick_size`. These tests use the default `tick_size` (1e9) so tick `100`
@@ -42,8 +42,7 @@ const HIGH_VARIANCE_A: u64 = 100_000_000;
 const Q0: u64 = 10_000_000_000;
 const Q1: u64 = 2_000_000_000;
 const Q2: u64 = 2_000_000_000;
-const DEAD_QUANTITY: u64 = 3_000_000_000;
-const LIVE_QUANTITY: u64 = 5_000_000_000;
+const ADJACENT_QUANTITY: u64 = 5_000_000_000;
 /// Forward far above the grid so low strikes sit in the deep-ITM flat price tail
 /// where adjacent ticks price within a floor bucket — the dust-underflow regime.
 const FLAT_REGION_FORWARD: u64 = 435_000_000_000;
@@ -105,20 +104,27 @@ fun interpolation_collapses_subtree_within_bound() {
 }
 
 #[test]
-fun skip_zero_delta_ignores_dead_boundaries() {
+fun skip_zero_delta_keeps_adjacent_live_ranges_exact() {
     let (mut fixture, oracle, pricer) = live_pricer();
     let mut tree = strike_payout_tree::new(fixture.scenario_mut().ctx());
 
     let (t0, t1, t2) = clustered_ticks();
-    // Insert then fully remove a finite range: its boundary nodes persist (the
-    // treap never GCs) with zeroed local quantity -> skip-zero-delta must skip them.
-    tree.insert_range(t1, t2, DEAD_QUANTITY, 0);
-    tree.remove_range(t1, t2, DEAD_QUANTITY, 0);
-    insert_up(&mut tree, t0, LIVE_QUANTITY);
+    // Adjacent live ranges with the same quantity leave an equal nonzero start/end
+    // at the shared boundary. The exact walk may skip pricing that boundary because
+    // the two sides cancel.
+    tree.insert_range(t0, t1, ADJACENT_QUANTITY, 0);
+    tree.insert_range(t1, t2, ADJACENT_QUANTITY, 0);
 
-    // Only the live order is valued; the dead t1/t2 nodes contribute nothing.
     let walk = tree.walk_linear(&pricer, tick_size(), 0);
-    assert_eq!(walk, up_reference(&pricer, vector[t0], vector[LIVE_QUANTITY]));
+    assert_eq!(
+        walk,
+        range_reference(
+            &pricer,
+            vector[t0, t1],
+            vector[t1, t2],
+            vector[ADJACENT_QUANTITY, ADJACENT_QUANTITY],
+        ),
+    );
 
     destroy(tree);
     cleanup(fixture, oracle);
@@ -185,6 +191,22 @@ fun up_reference(pricer: &Pricer, ticks: vector<u64>, quantities: vector<u64>):
     total
 }
 
+/// Independent finite-range reference: `Σ mul(range_price(lower·ts, higher·ts), quantity)`.
+/// Uses `range_price` (a different pricer path than the walk's `up_price`).
+fun range_reference(
+    pricer: &Pricer,
+    lower_ticks: vector<u64>,
+    higher_ticks: vector<u64>,
+    quantities: vector<u64>,
+): u64 {
+    let mut total = 0;
+    lower_ticks.length().do!(|i| {
+        let range_price = pricer.range_price(raw(lower_ticks[i]), raw(higher_ticks[i]));
+        total = total + math::mul(range_price, quantities[i]);
+    });
+    total
+}
+
 /// A live market at the default ATM forward with an inflated base variance so
 /// adjacent strikes are clustered in price, plus a `Pricer` snapshot over it.
 fun live_pricer(): (OracleFixture, OracleBundle, Pricer) {

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

@@ -102,6 +102,7 @@ fun new_returns_empty_tree() {
     // Empty tree has zero conservative backing and zero settled liability at any
     // settlement price.
     assert_reserve_terms(&tree, 0, 0);
+    assert_eq!(tree.debug_node_count(), 0);
     assert_eq!(tree.settled_payout_liability(settle_at_tick(0), TICK_SIZE), 0);
     assert_eq!(tree.settled_payout_liability(settle_at_tick(HIGH_SETTLEMENT_TICK), TICK_SIZE), 0);
     destroy(tree);
@@ -250,6 +251,7 @@ fun insert_with_both_terms_zero_is_no_op() {
     insert_range(&mut tree, 2, 6, 0, 0);
 
     assert_reserve_terms(&tree, 0, 0);
+    assert_eq!(tree.debug_node_count(), 0);
     destroy(tree);
 }
 
@@ -262,8 +264,15 @@ fun insert_then_remove_restores_empty_state() {
 
     insert_range(&mut tree, 2, 6, 50, 0);
     assert_reserve_terms(&tree, 50, 50);
+    assert!(tree.debug_contains_node(2));
+    assert!(tree.debug_contains_node(6));
+    assert_eq!(tree.debug_node_count(), 2);
+
     remove_range(&mut tree, 2, 6, 50, 0);
     assert_reserve_terms(&tree, 0, 0);
+    assert!(!tree.debug_contains_node(2));
+    assert!(!tree.debug_contains_node(6));
+    assert_eq!(tree.debug_node_count(), 0);
     destroy(tree);
 }
 
@@ -275,9 +284,33 @@ fun insert_two_then_remove_one_leaves_other() {
     insert_range(&mut tree, 1, 6, 40, 0);
     insert_range(&mut tree, 3, 7, 30, 0);
     assert_reserve_terms(&tree, 70, 70);
+    assert_eq!(tree.debug_node_count(), 4);
 
     remove_range(&mut tree, 3, 7, 30, 0);
     assert_reserve_terms(&tree, 40, 40);
+    assert!(tree.debug_contains_node(1));
+    assert!(tree.debug_contains_node(6));
+    assert!(!tree.debug_contains_node(3));
+    assert!(!tree.debug_contains_node(7));
+    assert_eq!(tree.debug_node_count(), 2);
+    destroy(tree);
+}
+
+#[test]
+fun remove_adjacent_range_preserves_shared_live_boundary() {
+    let ctx = &mut tx_context::dummy();
+    let mut tree = new_tree(ctx);
+
+    insert_range(&mut tree, 1, 3, 40, 0);
+    insert_range(&mut tree, 3, 7, 30, 0);
+    assert_eq!(tree.debug_node_count(), 3);
+
+    remove_range(&mut tree, 1, 3, 40, 0);
+    assert_reserve_terms(&tree, 30, 30);
+    assert!(!tree.debug_contains_node(1));
+    assert!(tree.debug_contains_node(3));
+    assert!(tree.debug_contains_node(7));
+    assert_eq!(tree.debug_node_count(), 2);
     destroy(tree);
 }