Collect all order before refunding

lib/lb_v2/test_suits.ak

@@ -1,5 +1,7 @@
 use aiken/builtin
+use aiken/bytearray
 use aiken/fuzz
+use aiken/list
 use aiken/transaction.{
   InlineDatum, Input, Output, OutputReference, TransactionId,
 }
@@ -14,23 +16,73 @@ use lb_v2/utils.{
 }
 use lb_v2/validation.{apply_collecting_orders}
 
-test test_sort_two_consecutive_factory_datum_1() {
-  let datum_a = FactoryDatum { head: #"0000", tail: #"00ff" }
-  let datum_b = FactoryDatum { head: #"00ff", tail: #"ffff" }
-  let (d1, d2) = sort_two_consecutive_factory_datum(datum_b, datum_a)
-  and {
-    builtin.serialise_data(d1) == builtin.serialise_data(datum_a),
-    builtin.serialise_data(d2) == builtin.serialise_data(datum_b),
+// dont use  fuzz.bytearray_between(64, 64) beacause it have a bug
+fn custom_factory_node() -> Fuzzer<ByteArray> {
+  let head = fuzz.bytearray()
+  let tail = fuzz.bytearray()
+  fuzz.map2(head, tail, fn(h, t) { builtin.append_bytearray(h, t) })
+}
+
+fn factory_params() -> Fuzzer<(ByteArray, ByteArray, ByteArray)> {
+  fuzz.map3(
+    fuzz_0: custom_factory_node(),
+    fuzz_1: custom_factory_node(),
+    fuzz_2: custom_factory_node(),
+    f: fn(x0, x1, x2) { (x0, x1, x2) },
+  )
+}
+
+test test_sort_two_consecutive_factory_datum_1(
+  factory_node via factory_params(),
+) {
+  let (a, b, c) = factory_node
+  expect [x, y, z] = list.sort([a, b, c], bytearray.compare)
+  if and {
+    x != y,
+    y != z,
+  } {
+    let datum_a = FactoryDatum { head: x, tail: y }
+    let datum_b = FactoryDatum { head: y, tail: z }
+    let (d1, d2) = sort_two_consecutive_factory_datum(datum_b, datum_a)
+    and {
+      builtin.serialise_data(d1) == builtin.serialise_data(datum_a),
+      builtin.serialise_data(d2) == builtin.serialise_data(datum_b),
+    }
+  } else {
+    True
   }
 }
 
-test test_sort_two_consecutive_factory_datum_2() {
-  let datum_a = FactoryDatum { head: #"00ff", tail: #"ffff" }
-  let datum_b = FactoryDatum { head: #"0000", tail: #"00ff" }
-  let (d1, d2) = sort_two_consecutive_factory_datum(datum_b, datum_a)
-  and {
-    builtin.serialise_data(d1) == builtin.serialise_data(datum_b),
-    builtin.serialise_data(d2) == builtin.serialise_data(datum_a),
+test test_sort_two_consecutive_factory_datum_2(
+  factory_node via factory_params(),
+) {
+  let (a, b, _) = factory_node
+  expect [x, y] = list.sort([a, b], bytearray.compare)
+  if x != y {
+    // datum_a.head == initial head
+    let datum_a = FactoryDatum { head: #"00", tail: x }
+    let datum_b = FactoryDatum { head: x, tail: y }
+    let (d1, d2) = sort_two_consecutive_factory_datum(datum_b, datum_a)
+    expect and {
+        builtin.serialise_data(d1) == builtin.serialise_data(datum_a),
+        builtin.serialise_data(d2) == builtin.serialise_data(datum_b),
+      }
+
+    // datum_b.tail == initial tail
+    let datum_a = FactoryDatum { head: x, tail: y }
+    let datum_b =
+      FactoryDatum {
+        head: y,
+        tail: #"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00",
+      }
+    let (d1, d2) = sort_two_consecutive_factory_datum(datum_b, datum_a)
+    expect and {
+        builtin.serialise_data(d1) == builtin.serialise_data(datum_a),
+        builtin.serialise_data(d2) == builtin.serialise_data(datum_b),
+      }
+    True
+  } else {
+    True
   }
 }
 

lib/lb_v2/validation.ak

@@ -983,7 +983,6 @@ pub fn validate_collect_order(
     collected_fund,
     base_asset,
     raise_asset,
-    is_cancelled,
     is_manager_collected,
     reserve_raise,
     total_penalty,
@@ -1033,12 +1032,9 @@ pub fn validate_collect_order(
     ),
     // 3. validate time range(no need to check because It must collect seller first)
     //    - datum.end_time < start_valid_time_range
-    // 4. collect manager
-    is_manager_collected == True,
     // 5. Mint nothing
     value.flatten(mint_value) == [],
-    // 6. Not cancel yet
-    is_cancelled == False,
+    // 6. Dont care about cancelation
     // 7. Collected manager
     is_manager_collected == True,
     // 8. Reach min raise
@@ -1475,15 +1471,17 @@ pub fn validate_refund(
   //        - value_out =  minimum_ada+ refund_amount(refund_amount= amount+penalty )
   //        - address = owner of order input datum
   //    - calculate all order fund
-  let (total_orders_collected_fund, total_orders_amount, total_orders_penalty) =
+  let (total_orders_amount, total_orders_penalty) =
     apply_refund_orders(
       order_inputs: order_inputs,
       outputs: outputs,
       base_asset: base_asset,
       raise_asset: raise_asset,
     )
-
+  let orders_collected_fund = total_orders_amount + total_orders_penalty
   and {
+    // check this LBE collected all orders
+    collected_fund == reserve_raise + total_penalty,
     // 2. validate treasury.
     //    - treasury_datum
     //      - is_cancelled = True
@@ -1496,13 +1494,13 @@ pub fn validate_refund(
     is_cancelled == True,
     treasury_out_datum == TreasuryDatum {
       ..treasury_in_datum,
-      collected_fund: collected_fund - total_orders_collected_fund,
+      collected_fund: collected_fund - orders_collected_fund,
       reserve_raise: reserve_raise - total_orders_amount,
       total_penalty: total_penalty - total_orders_penalty,
     },
     treasury_out_value == (
       treasury_in_value
-        |> value.add(raise_asset_pid, raise_asset_an, -total_orders_collected_fund)
+        |> value.add(raise_asset_pid, raise_asset_an, -orders_collected_fund)
     ),
     // 3. Mint: burn order NFT
     value.flatten(mint_value) == [
@@ -1519,31 +1517,27 @@ pub fn apply_refund_orders(
   outputs: List<Output>,
   base_asset: Asset,
   raise_asset: Asset,
-) -> (Int, Int, Int) {
+) -> (Int, Int) {
   expect [order_input, ..remaining_order_inputs] = order_inputs
   expect Input {
     output: Output { datum: InlineDatum(raw_order_in_datum), .. },
     ..
   } = order_input
   expect order_in_datum: OrderDatum = raw_order_in_datum
   expect [order_output, ..remaining_outputs] = outputs
-  let (collected_fund, amount, penalty_amount) =
+  let (amount, penalty_amount) =
     apply_refund_order(order_in_datum, order_output, base_asset, raise_asset)
   if remaining_order_inputs == [] {
-    (collected_fund, amount, penalty_amount)
+    (amount, penalty_amount)
   } else {
-    let (acc_collected_fund, acc_amount, acc_penalty) =
+    let (acc_amount, acc_penalty) =
       apply_refund_orders(
         remaining_order_inputs,
         remaining_outputs,
         base_asset,
         raise_asset,
       )
-    (
-      acc_collected_fund + collected_fund,
-      acc_amount + amount,
-      acc_penalty + penalty_amount,
-    )
+    (acc_amount + amount, acc_penalty + penalty_amount)
   }
 }
 
@@ -1552,7 +1546,7 @@ fn apply_refund_order(
   order_output: Output,
   base_asset: Asset,
   raise_asset: Asset,
-) -> (Int, Int, Int) {
+) -> (Int, Int) {
   let OrderDatum {
     base_asset: o_base_asset,
     raise_asset: o_raise_asset,
@@ -1565,15 +1559,9 @@ fn apply_refund_order(
 
   let Asset { policy_id: raise_asset_pid, asset_name: raise_asset_an } =
     raise_asset
-  let order_out_base_ada_amount =
-    if is_collected {
-      minimum_ada
-    } else {
-      minimum_ada + fee_ada
-    }
   let expected_order_out_value =
     value.zero()
-      |> value.add(ada_policy_id, ada_asset_name, order_out_base_ada_amount)
+      |> value.add(ada_policy_id, ada_asset_name, minimum_ada)
       |> value.add(raise_asset_pid, raise_asset_an, amount + penalty_amount)
   let Output { address: owner_address, value: order_out_value, .. } =
     order_output
@@ -1582,16 +1570,9 @@ fn apply_refund_order(
       raise_asset == o_raise_asset,
       owner_address == owner,
       expected_order_out_value == order_out_value,
+      is_collected == True,
     }
-  (
-    if is_collected {
-      amount + penalty_amount
-    } else {
-      0
-    },
-    amount,
-    penalty_amount,
-  )
+  (amount, penalty_amount)
 }
 
 pub fn validate_manage_seller(