using globals

Author: benesjan

noir-projects/noir-contracts/contracts/app/orderbook_contract/src/test/test.nr

@@ -11,24 +11,25 @@ use aztec::{
 use token::Token;
 use uint_note::uint_note::PartialUintNote;
 
+global BID_AMOUNT: u128 = 1000;
+global ASK_AMOUNT: u128 = 2000;
+global CREATE_ORDER_AUTHWIT_NONCE: u128 = 1;
+global FULFILL_ORDER_AUTHWIT_NONCE: u128 = 2;
+
 #[test]
 unconstrained fn create_order_happy_path() {
     let (mut env, orderbook_address, token0_address, token1_address, owner, _) =
         setup_orderbook_with_tokens(true);
 
-    let bid_amount = 1000 as u128;
-    let ask_amount = 2000 as u128;
-    let authwit_nonce = 1;
-
     // Mint tokens to owner
-    mint_to_private(env, token0_address, owner, owner, bid_amount);
+    mint_to_private(env, token0_address, owner, owner, BID_AMOUNT);
 
     // Create authwit for transferring tokens to orderbook
     let transfer_call_interface = Token::at(token0_address).transfer_to_public(
         owner,
         orderbook_address,
-        bid_amount,
-        authwit_nonce,
+        BID_AMOUNT,
+        CREATE_ORDER_AUTHWIT_NONCE,
     );
     add_private_authwit_from_call_interface(owner, orderbook_address, transfer_call_interface);
 
@@ -38,14 +39,14 @@ unconstrained fn create_order_happy_path() {
         Orderbook::at(orderbook_address).create_order(
             token0_address,
             token1_address,
-            bid_amount,
-            ask_amount,
-            authwit_nonce,
+            BID_AMOUNT,
+            ASK_AMOUNT,
+            CREATE_ORDER_AUTHWIT_NONCE,
         ),
     );
 
     // Verify tokens were transferred to orderbook's public balance
-    check_public_balance(env, token0_address, orderbook_address, bid_amount);
+    check_public_balance(env, token0_address, orderbook_address, BID_AMOUNT);
     check_private_balance(env, token0_address, owner, 0);
 }
 
@@ -55,21 +56,17 @@ unconstrained fn full_flow() {
         setup_orderbook_with_tokens(true);
 
     let taker = env.create_contract_account();
-    let bid_amount = 1000 as u128;
-    let ask_amount = 2000 as u128;
-    let authwit_nonce_create = 1;
-    let authwit_nonce_fulfill = 2;
 
     // Setup: mint tokens to maker and taker
-    mint_to_private(env, token0_address, maker, maker, bid_amount);
-    mint_to_private(env, token1_address, maker, taker, ask_amount);
+    mint_to_private(env, token0_address, maker, maker, BID_AMOUNT);
+    mint_to_private(env, token1_address, maker, taker, ASK_AMOUNT);
 
     // Create order first
     let transfer_call_interface = Token::at(token0_address).transfer_to_public(
         maker,
         orderbook_address,
-        bid_amount,
-        authwit_nonce_create,
+        BID_AMOUNT,
+        CREATE_ORDER_AUTHWIT_NONCE,
     );
     add_private_authwit_from_call_interface(maker, orderbook_address, transfer_call_interface);
 
@@ -78,18 +75,18 @@ unconstrained fn full_flow() {
         Orderbook::at(orderbook_address).create_order(
             token0_address,
             token1_address,
-            bid_amount,
-            ask_amount,
-            authwit_nonce_create,
+            BID_AMOUNT,
+            ASK_AMOUNT,
+            CREATE_ORDER_AUTHWIT_NONCE,
         ),
     );
 
     // Get order and verify it's active
     let (order, is_fulfilled) =
         env.simulate_utility(Orderbook::at(orderbook_address).get_order(order_id));
 
-    assert_eq(order.bid_amount, bid_amount);
-    assert_eq(order.ask_amount, ask_amount);
+    assert_eq(order.bid_amount, BID_AMOUNT);
+    assert_eq(order.ask_amount, ASK_AMOUNT);
     assert_eq(order.bid_token_is_zero, true); // token0 -> token1
     assert_eq(is_fulfilled, false);
 
@@ -100,8 +97,8 @@ unconstrained fn full_flow() {
         .finalize_transfer_to_private_from_private(
             taker,
             maker_partial_note,
-            ask_amount,
-            authwit_nonce_fulfill,
+            ASK_AMOUNT,
+            FULFILL_ORDER_AUTHWIT_NONCE,
         );
     add_private_authwit_from_call_interface(
         taker,
@@ -112,21 +109,21 @@ unconstrained fn full_flow() {
     // Fulfill order
     env.call_private(
         taker,
-        Orderbook::at(orderbook_address).fulfill_order(order_id, authwit_nonce_fulfill),
+        Orderbook::at(orderbook_address).fulfill_order(order_id, FULFILL_ORDER_AUTHWIT_NONCE),
     );
 
     // Verify final balances
     check_private_balance(env, token0_address, maker, 0);
-    check_private_balance(env, token1_address, maker, ask_amount);
-    check_private_balance(env, token0_address, taker, bid_amount);
+    check_private_balance(env, token1_address, maker, ASK_AMOUNT);
+    check_private_balance(env, token0_address, taker, BID_AMOUNT);
     check_private_balance(env, token1_address, taker, 0);
 
     // Get order and verify it's fulfilled
     let (order, is_fulfilled) =
         env.simulate_utility(Orderbook::at(orderbook_address).get_order(order_id));
 
-    assert_eq(order.bid_amount, bid_amount);
-    assert_eq(order.ask_amount, ask_amount);
+    assert_eq(order.bid_amount, BID_AMOUNT);
+    assert_eq(order.ask_amount, ASK_AMOUNT);
     assert_eq(order.bid_token_is_zero, true); // token0 -> token1
     assert_eq(is_fulfilled, true);
 }
@@ -137,17 +134,15 @@ unconstrained fn create_order_zero_bid_amount() {
         setup_orderbook_with_tokens(false);
 
     let bid_amount = 0 as u128;
-    let ask_amount = 2000 as u128;
-    let authwit_nonce = 1;
 
     let _order_id = env.call_private(
         owner,
         Orderbook::at(orderbook_address).create_order(
             token0_address,
             token1_address,
             bid_amount,
-            ask_amount,
-            authwit_nonce,
+            ASK_AMOUNT,
+            CREATE_ORDER_AUTHWIT_NONCE,
         ),
     );
 }
@@ -157,18 +152,16 @@ unconstrained fn create_order_zero_ask_amount() {
     let (mut env, orderbook_address, token0_address, token1_address, owner, _) =
         setup_orderbook_with_tokens(false);
 
-    let bid_amount = 1000 as u128;
     let ask_amount = 0 as u128;
-    let authwit_nonce = 1;
 
     let _order_id = env.call_private(
         owner,
         Orderbook::at(orderbook_address).create_order(
             token0_address,
             token1_address,
-            bid_amount,
+            BID_AMOUNT,
             ask_amount,
-            authwit_nonce,
+            CREATE_ORDER_AUTHWIT_NONCE,
         ),
     );
 }
@@ -179,18 +172,15 @@ unconstrained fn create_order_invalid_bid_token() {
         setup_orderbook_with_tokens(false);
 
     let invalid_token = AztecAddress::from_field(999);
-    let bid_amount = 1000 as u128;
-    let ask_amount = 2000 as u128;
-    let authwit_nonce = 1;
 
     let _order_id = env.call_private(
         owner,
         Orderbook::at(orderbook_address).create_order(
             invalid_token,
             token1_address,
-            bid_amount,
-            ask_amount,
-            authwit_nonce,
+            BID_AMOUNT,
+            ASK_AMOUNT,
+            CREATE_ORDER_AUTHWIT_NONCE,
         ),
     );
 }
@@ -201,18 +191,15 @@ unconstrained fn create_order_invalid_ask_token() {
         setup_orderbook_with_tokens(false);
 
     let invalid_token = AztecAddress::from_field(999);
-    let bid_amount = 1000 as u128;
-    let ask_amount = 2000 as u128;
-    let authwit_nonce = 1;
 
     let _order_id = env.call_private(
         owner,
         Orderbook::at(orderbook_address).create_order(
             token0_address,
             invalid_token,
-            bid_amount,
-            ask_amount,
-            authwit_nonce,
+            BID_AMOUNT,
+            ASK_AMOUNT,
+            CREATE_ORDER_AUTHWIT_NONCE,
         ),
     );
 }
@@ -222,18 +209,14 @@ unconstrained fn create_order_same_tokens() {
     let (mut env, orderbook_address, token0_address, _token1_address, owner, _) =
         setup_orderbook_with_tokens(false);
 
-    let bid_amount = 1000 as u128;
-    let ask_amount = 2000 as u128;
-    let authwit_nonce = 1;
-
     let _order_id = env.call_private(
         owner,
         Orderbook::at(orderbook_address).create_order(
             token0_address,
             token0_address,
-            bid_amount,
-            ask_amount,
-            authwit_nonce,
+            BID_AMOUNT,
+            ASK_AMOUNT,
+            CREATE_ORDER_AUTHWIT_NONCE,
         ),
     );
 }