separate account for maker

Author: benesjan

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

@@ -13,23 +13,23 @@ global FULFILL_ORDER_AUTHWIT_NONCE: Field = 2;
 
 #[test]
 unconstrained fn create_order_happy_path() {
-    let (mut env, orderbook_address, token0_address, token1_address, owner) =
+    let (mut env, orderbook_address, token0_address, token1_address, minter, maker) =
         setup_orderbook_with_tokens(true);
 
     let token0 = Token::at(token0_address);
     let orderbook = Orderbook::at(orderbook_address);
 
-    // Mint tokens to owner
-    env.call_private(owner, Token::at(token0_address).mint_to_private(owner, BID_AMOUNT));
+    // Mint tokens to maker
+    env.call_private(minter, Token::at(token0_address).mint_to_private(maker, BID_AMOUNT));
 
     // Create authwit for transferring tokens to orderbook
     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);
+        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);
 
     // Create order
     let _order_id = env.call_private(
-        owner,
+        maker,
         orderbook.create_order(
             token0_address,
             token1_address,
@@ -41,12 +41,12 @@ unconstrained fn create_order_happy_path() {
 
     // Verify tokens were transferred to orderbook's public balance
     assert_eq(env.view_public(token0.balance_of_public(orderbook_address)), BID_AMOUNT);
-    assert_eq(env.simulate_utility(token0.balance_of_private(owner)), 0);
+    assert_eq(env.simulate_utility(token0.balance_of_private(maker)), 0);
 }
 
 #[test]
 unconstrained fn full_flow() {
-    let (mut env, orderbook_address, token0_address, token1_address, maker) =
+    let (mut env, orderbook_address, token0_address, token1_address, minter, maker) =
         setup_orderbook_with_tokens(true);
 
     let token0 = Token::at(token0_address);
@@ -55,10 +55,9 @@ unconstrained fn full_flow() {
 
     let taker = env.create_contract_account();
 
-    // Setup: mint tokens to maker and taker
-
-    env.call_private(maker, token0.mint_to_private(maker, BID_AMOUNT));
-    env.call_private(maker, token1.mint_to_private(taker, ASK_AMOUNT));
+    // Mint tokens to maker and taker
+    env.call_private(minter, token0.mint_to_private(maker, BID_AMOUNT));
+    env.call_private(minter, token1.mint_to_private(taker, ASK_AMOUNT));
 
     // Create order first
     let transfer_call_interface =
@@ -119,15 +118,15 @@ unconstrained fn full_flow() {
 
 #[test(should_fail_with = "ZERO_BID_AMOUNT")]
 unconstrained fn create_order_zero_bid_amount() {
-    let (mut env, orderbook_address, token0_address, token1_address, owner) =
+    let (mut env, orderbook_address, token0_address, token1_address, _, maker) =
         setup_orderbook_with_tokens(false);
 
     let orderbook = Orderbook::at(orderbook_address);
 
     let bid_amount = 0 as u128;
 
     let _order_id = env.call_private(
-        owner,
+        maker,
         orderbook.create_order(
             token0_address,
             token1_address,
@@ -140,15 +139,15 @@ unconstrained fn create_order_zero_bid_amount() {
 
 #[test(should_fail_with = "ZERO_ASK_AMOUNT")]
 unconstrained fn create_order_zero_ask_amount() {
-    let (mut env, orderbook_address, token0_address, token1_address, owner) =
+    let (mut env, orderbook_address, token0_address, token1_address, _, maker) =
         setup_orderbook_with_tokens(false);
 
     let orderbook = Orderbook::at(orderbook_address);
 
     let ask_amount = 0 as u128;
 
     let _order_id = env.call_private(
-        owner,
+        maker,
         orderbook.create_order(
             token0_address,
             token1_address,
@@ -161,15 +160,15 @@ unconstrained fn create_order_zero_ask_amount() {
 
 #[test(should_fail_with = "BID_TOKEN_IS_INVALID")]
 unconstrained fn create_order_invalid_bid_token() {
-    let (mut env, orderbook_address, _token0_address, token1_address, owner) =
+    let (mut env, orderbook_address, _token0_address, token1_address, _, maker) =
         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,
+        maker,
         orderbook.create_order(
             invalid_token,
             token1_address,
@@ -182,15 +181,15 @@ unconstrained fn create_order_invalid_bid_token() {
 
 #[test(should_fail_with = "ASK_TOKEN_IS_INVALID")]
 unconstrained fn create_order_invalid_ask_token() {
-    let (mut env, orderbook_address, token0_address, _token1_address, owner) =
+    let (mut env, orderbook_address, token0_address, _token1_address, _, maker) =
         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,
+        maker,
         orderbook.create_order(
             token0_address,
             invalid_token,
@@ -203,13 +202,13 @@ unconstrained fn create_order_invalid_ask_token() {
 
 #[test(should_fail_with = "SAME_TOKEN_TRADE")]
 unconstrained fn create_order_same_tokens() {
-    let (mut env, orderbook_address, token0_address, _token1_address, owner) =
+    let (mut env, orderbook_address, token0_address, _token1_address, _, maker) =
         setup_orderbook_with_tokens(false);
 
     let orderbook = Orderbook::at(orderbook_address);
 
     let _order_id = env.call_private(
-        owner,
+        maker,
         orderbook.create_order(
             token0_address,
             token0_address,

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

@@ -6,50 +6,60 @@ use token::Token;
 
 // Utility function to setup two token contracts
 // TODO(#16560): Make it possible to return a contract instance directly from setup func
-pub(crate) unconstrained fn setup_tokens(
+unconstrained fn setup_tokens(
     env: &mut TestEnvironment,
-    owner: AztecAddress,
+    admin: AztecAddress,
 ) -> (AztecAddress, AztecAddress) {
     // Deploy first token contract
     let token0_initializer = Token::interface().constructor(
-        owner,
+        admin,
         "Token00000000000000000000000000",
         "TK00000000000000000000000000000",
         18,
     );
     let token0_address =
-        env.deploy("@token_contract/Token").with_public_initializer(owner, token0_initializer);
+        env.deploy("@token_contract/Token").with_public_initializer(admin, token0_initializer);
 
     // Deploy second token contract
     let token1_initializer = Token::interface().constructor(
-        owner,
+        admin,
         "Token11111111111111111111111111",
         "TK11111111111111111111111111111",
         18,
     );
     let token1_address =
-        env.deploy("@token_contract/Token").with_public_initializer(owner, token1_initializer);
+        env.deploy("@token_contract/Token").with_public_initializer(admin, token1_initializer);
 
     (token0_address, token1_address)
 }
 
 // Utility function to setup orderbook with two tokens
 pub(crate) unconstrained fn setup_orderbook_with_tokens(
     with_account_contracts: bool,
-) -> (TestEnvironment, AztecAddress, AztecAddress, AztecAddress, AztecAddress) {
+) -> (TestEnvironment, AztecAddress, AztecAddress, AztecAddress, AztecAddress, AztecAddress) {
     let mut env = TestEnvironment::new();
-    let owner = if with_account_contracts {
+    let admin = if with_account_contracts {
         env.create_contract_account()
     } else {
         env.create_light_account()
     };
 
-    let (token0_address, token1_address) = setup_tokens(&mut env, owner);
+    let maker = if with_account_contracts {
+        env.create_contract_account()
+    } else {
+        env.create_light_account()
+    };
+
+    let (token0_address, token1_address) = setup_tokens(&mut env, admin);
 
     // Deploy orderbook contract
     let orderbook_initializer = Orderbook::interface().constructor(token0_address, token1_address);
     let orderbook_address =
-        env.deploy("Orderbook").with_public_initializer(owner, orderbook_initializer);
+        env.deploy("Orderbook").with_public_initializer(admin, orderbook_initializer);
+
+    // Admin has minter role and since where this function is used we care about minter role and not about admin role
+    // we name the return value a minter.
+    let minter = admin;
 
-    (env, orderbook_address, token0_address, token1_address, owner)
+    (env, orderbook_address, token0_address, token1_address, minter, maker)
 }