unnecessary setup funcs cleanup

Author: benesjan

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

@@ -1,9 +1,4 @@
-use crate::{
-    Orderbook,
-    test::utils::{
-        check_private_balance, check_public_balance, mint_to_private, setup_orderbook_with_tokens,
-    },
-};
+use crate::{Orderbook, test::utils::setup_orderbook_with_tokens};
 use aztec::{
     protocol_types::{address::AztecAddress, traits::FromField},
     test::helpers::authwit::add_private_authwit_from_call_interface,
@@ -21,22 +16,21 @@ unconstrained fn create_order_happy_path() {
     let (mut env, orderbook_address, token0_address, token1_address, owner, _) =
         setup_orderbook_with_tokens(true);
 
+    let token0 = Token::at(token0_address);
+    let orderbook = Orderbook::at(orderbook_address);
+
     // Mint tokens to owner
-    mint_to_private(env, token0_address, owner, owner, BID_AMOUNT);
+    env.call_private(owner, Token::at(token0_address).mint_to_private(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,
-        CREATE_ORDER_AUTHWIT_NONCE,
-    );
+    let transfer_call_interface =
+        token0.transfer_to_public(owner, orderbook_address, BID_AMOUNT, CREATE_ORDER_AUTHWIT_NONCE);
     add_private_authwit_from_call_interface(owner, orderbook_address, transfer_call_interface);
 
     // Create order
     let _order_id = env.call_private(
         owner,
-        Orderbook::at(orderbook_address).create_order(
+        orderbook.create_order(
             token0_address,
             token1_address,
             BID_AMOUNT,
@@ -46,33 +40,34 @@ unconstrained fn create_order_happy_path() {
     );
 
     // Verify tokens were transferred to orderbook's public balance
-    check_public_balance(env, token0_address, orderbook_address, BID_AMOUNT);
-    check_private_balance(env, token0_address, owner, 0);
+    assert_eq(env.view_public(token0.balance_of_public(orderbook_address)), BID_AMOUNT);
+    assert_eq(env.simulate_utility(token0.balance_of_private(owner)), 0);
 }
 
 #[test]
 unconstrained fn full_flow() {
     let (mut env, orderbook_address, token0_address, token1_address, maker, _) =
         setup_orderbook_with_tokens(true);
 
+    let token0 = Token::at(token0_address);
+    let token1 = Token::at(token1_address);
+    let orderbook = Orderbook::at(orderbook_address);
+
     let taker = env.create_contract_account();
 
     // 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);
+
+    env.call_private(maker, token0.mint_to_private(maker, BID_AMOUNT));
+    env.call_private(maker, token1.mint_to_private(taker, ASK_AMOUNT));
 
     // Create order first
-    let transfer_call_interface = Token::at(token0_address).transfer_to_public(
-        maker,
-        orderbook_address,
-        BID_AMOUNT,
-        CREATE_ORDER_AUTHWIT_NONCE,
-    );
+    let transfer_call_interface =
+        token0.transfer_to_public(maker, orderbook_address, BID_AMOUNT, CREATE_ORDER_AUTHWIT_NONCE);
     add_private_authwit_from_call_interface(maker, orderbook_address, transfer_call_interface);
 
     let order_id = env.call_private(
         maker,
-        Orderbook::at(orderbook_address).create_order(
+        orderbook.create_order(
             token0_address,
             token1_address,
             BID_AMOUNT,
@@ -82,8 +77,7 @@ unconstrained fn full_flow() {
     );
 
     // Get order and verify it's active
-    let (order, is_fulfilled) =
-        env.simulate_utility(Orderbook::at(orderbook_address).get_order(order_id));
+    let (order, is_fulfilled) = env.simulate_utility(orderbook.get_order(order_id));
 
     assert_eq(order.bid_amount, BID_AMOUNT);
     assert_eq(order.ask_amount, ASK_AMOUNT);
@@ -93,34 +87,29 @@ unconstrained fn full_flow() {
     // Create authwit for taker to transfer ask tokens
     // Convert order_id back to PartialUintNote as the orderbook does
     let maker_partial_note = PartialUintNote::from_field(order_id);
-    let fulfill_transfer_call_interface = Token::at(token1_address)
-        .finalize_transfer_to_private_from_private(
-            taker,
-            maker_partial_note,
-            ASK_AMOUNT,
-            FULFILL_ORDER_AUTHWIT_NONCE,
-        );
+    let fulfill_transfer_call_interface = token1.finalize_transfer_to_private_from_private(
+        taker,
+        maker_partial_note,
+        ASK_AMOUNT,
+        FULFILL_ORDER_AUTHWIT_NONCE,
+    );
     add_private_authwit_from_call_interface(
         taker,
         orderbook_address,
         fulfill_transfer_call_interface,
     );
 
     // Fulfill order
-    env.call_private(
-        taker,
-        Orderbook::at(orderbook_address).fulfill_order(order_id, FULFILL_ORDER_AUTHWIT_NONCE),
-    );
+    env.call_private(taker, orderbook.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, taker, 0);
+    assert_eq(env.simulate_utility(token0.balance_of_private(maker)), 0);
+    assert_eq(env.simulate_utility(token1.balance_of_private(maker)), ASK_AMOUNT);
+    assert_eq(env.simulate_utility(token0.balance_of_private(taker)), BID_AMOUNT);
+    assert_eq(env.simulate_utility(token1.balance_of_private(taker)), 0);
 
     // Get order and verify it's fulfilled
-    let (order, is_fulfilled) =
-        env.simulate_utility(Orderbook::at(orderbook_address).get_order(order_id));
+    let (order, is_fulfilled) = env.simulate_utility(orderbook.get_order(order_id));
 
     assert_eq(order.bid_amount, BID_AMOUNT);
     assert_eq(order.ask_amount, ASK_AMOUNT);
@@ -133,11 +122,13 @@ unconstrained fn create_order_zero_bid_amount() {
     let (mut env, orderbook_address, token0_address, token1_address, owner, _) =
         setup_orderbook_with_tokens(false);
 
+    let orderbook = Orderbook::at(orderbook_address);
+
     let bid_amount = 0 as u128;
 
     let _order_id = env.call_private(
         owner,
-        Orderbook::at(orderbook_address).create_order(
+        orderbook.create_order(
             token0_address,
             token1_address,
             bid_amount,
@@ -152,11 +143,13 @@ unconstrained fn create_order_zero_ask_amount() {
     let (mut env, orderbook_address, token0_address, token1_address, owner, _) =
         setup_orderbook_with_tokens(false);
 
+    let orderbook = Orderbook::at(orderbook_address);
+
     let ask_amount = 0 as u128;
 
     let _order_id = env.call_private(
         owner,
-        Orderbook::at(orderbook_address).create_order(
+        orderbook.create_order(
             token0_address,
             token1_address,
             BID_AMOUNT,
@@ -171,11 +164,13 @@ unconstrained fn create_order_invalid_bid_token() {
     let (mut env, orderbook_address, _token0_address, token1_address, owner, _) =
         setup_orderbook_with_tokens(false);
 
+    let orderbook = Orderbook::at(orderbook_address);
+
     let invalid_token = AztecAddress::from_field(999);
 
     let _order_id = env.call_private(
         owner,
-        Orderbook::at(orderbook_address).create_order(
+        orderbook.create_order(
             invalid_token,
             token1_address,
             BID_AMOUNT,
@@ -190,11 +185,13 @@ unconstrained fn create_order_invalid_ask_token() {
     let (mut env, orderbook_address, token0_address, _token1_address, owner, _) =
         setup_orderbook_with_tokens(false);
 
+    let orderbook = Orderbook::at(orderbook_address);
+
     let invalid_token = AztecAddress::from_field(999);
 
     let _order_id = env.call_private(
         owner,
-        Orderbook::at(orderbook_address).create_order(
+        orderbook.create_order(
             token0_address,
             invalid_token,
             BID_AMOUNT,
@@ -209,9 +206,11 @@ unconstrained fn create_order_same_tokens() {
     let (mut env, orderbook_address, token0_address, _token1_address, owner, _) =
         setup_orderbook_with_tokens(false);
 
+    let orderbook = Orderbook::at(orderbook_address);
+
     let _order_id = env.call_private(
         owner,
-        Orderbook::at(orderbook_address).create_order(
+        orderbook.create_order(
             token0_address,
             token0_address,
             BID_AMOUNT,

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

@@ -52,40 +52,3 @@ pub(crate) unconstrained fn setup_orderbook_with_tokens(
 
     (env, orderbook_address, token0_address, token1_address, owner, owner)
 }
-
-// Utility function to mint tokens to private balance
-pub(crate) unconstrained fn mint_to_private(
-    env: TestEnvironment,
-    token_address: AztecAddress,
-    owner: AztecAddress,
-    to: AztecAddress,
-    amount: u128,
-) {
-    env.call_private(owner, Token::at(token_address).mint_to_private(to, amount));
-}
-
-// Utility function to check private balance
-pub(crate) unconstrained fn check_private_balance(
-    env: TestEnvironment,
-    token_address: AztecAddress,
-    address: AztecAddress,
-    expected_amount: u128,
-) {
-    assert_eq(
-        env.simulate_utility(Token::at(token_address).balance_of_private(address)),
-        expected_amount,
-    );
-}
-
-// Utility function to check public balance
-pub(crate) unconstrained fn check_public_balance(
-    env: TestEnvironment,
-    token_address: AztecAddress,
-    address: AztecAddress,
-    expected_amount: u128,
-) {
-    assert_eq(
-        env.view_public(Token::at(token_address).balance_of_public(address)),
-        expected_amount,
-    );
-}