test: Orderbook TXE tests

Author: benesjan

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

@@ -1,5 +1,6 @@
 mod config;
 mod order;
+mod test;
 
 use aztec::macros::aztec;
 

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

@@ -0,0 +1,331 @@
+use crate::Orderbook;
+use aztec::{
+    protocol_types::{address::AztecAddress, traits::FromField},
+    test::helpers::{
+        authwit::add_private_authwit_from_call_interface, test_environment::TestEnvironment,
+    },
+};
+use token::Token;
+use uint_note::uint_note::PartialUintNote;
+
+// Utility function to setup two token contracts
+unconstrained fn setup_tokens(
+    env: &mut TestEnvironment,
+    owner: AztecAddress,
+) -> (AztecAddress, AztecAddress) {
+    // Deploy first token contract
+    let token0_initializer = Token::interface().constructor(
+        owner,
+        "Token00000000000000000000000000",
+        "TK00000000000000000000000000000",
+        18,
+    );
+    let token0_address =
+        env.deploy("@token_contract/Token").with_public_initializer(owner, token0_initializer);
+
+    // Deploy second token contract
+    let token1_initializer = Token::interface().constructor(
+        owner,
+        "Token11111111111111111111111111",
+        "TK11111111111111111111111111111",
+        18,
+    );
+    let token1_address =
+        env.deploy("@token_contract/Token").with_public_initializer(owner, token1_initializer);
+
+    (token0_address, token1_address)
+}
+
+// Utility function to setup orderbook with two tokens
+unconstrained fn setup_orderbook_with_tokens(
+    with_account_contracts: bool,
+) -> (TestEnvironment, AztecAddress, AztecAddress, AztecAddress, AztecAddress, AztecAddress) {
+    let mut env = TestEnvironment::new();
+    let owner = if with_account_contracts {
+        env.create_contract_account()
+    } else {
+        env.create_light_account()
+    };
+
+    let (token0_address, token1_address) = setup_tokens(&mut env, owner);
+
+    // 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, orderbook_address, token0_address, token1_address, owner, owner)
+}
+
+// Utility function to mint tokens to private balance
+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
+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
+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,
+    );
+}
+
+// Happy path tests
+
+#[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);
+
+    // 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,
+    );
+    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(
+            token0_address,
+            token1_address,
+            bid_amount,
+            ask_amount,
+            authwit_nonce,
+        ),
+    );
+
+    // 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);
+}
+
+#[test]
+unconstrained fn full_flow() {
+    let (mut env, orderbook_address, token0_address, token1_address, maker, _) =
+        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);
+
+    // Create order first
+    let transfer_call_interface = Token::at(token0_address).transfer_to_public(
+        maker,
+        orderbook_address,
+        bid_amount,
+        authwit_nonce_create,
+    );
+    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(
+            token0_address,
+            token1_address,
+            bid_amount,
+            ask_amount,
+            authwit_nonce_create,
+        ),
+    );
+
+    // 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_token_is_zero, true); // token0 -> token1
+    assert_eq(is_fulfilled, false);
+
+    // 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,
+            authwit_nonce_fulfill,
+        );
+    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, authwit_nonce_fulfill),
+    );
+
+    // 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);
+
+    // 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_token_is_zero, true); // token0 -> token1
+    assert_eq(is_fulfilled, true);
+}
+
+// Unhappy path tests for create_order
+
+#[test(should_fail_with = "ZERO_BID_AMOUNT")]
+unconstrained fn create_order_zero_bid_amount() {
+    let (mut env, orderbook_address, token0_address, token1_address, owner, _) =
+        setup_orderbook_with_tokens(false);
+
+    let bid_amount = 0 as u128;
+    let ask_amount = 2000 as u128;
+    let authwit_nonce = 1;
+
+    // This should fail when creating the order due to zero bid amount
+    let _order_id = env.call_private(
+        owner,
+        Orderbook::at(orderbook_address).create_order(
+            token0_address,
+            token1_address,
+            bid_amount,
+            ask_amount,
+            authwit_nonce,
+        ),
+    );
+}
+
+#[test(should_fail_with = "ZERO_ASK_AMOUNT")]
+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;
+
+    // This should fail when creating the order due to zero ask amount
+    let _order_id = env.call_private(
+        owner,
+        Orderbook::at(orderbook_address).create_order(
+            token0_address,
+            token1_address,
+            bid_amount,
+            ask_amount,
+            authwit_nonce,
+        ),
+    );
+}
+
+#[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, _) =
+        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;
+
+    // This should fail due to invalid bid token
+    let _order_id = env.call_private(
+        owner,
+        Orderbook::at(orderbook_address).create_order(
+            invalid_token,
+            token1_address,
+            bid_amount,
+            ask_amount,
+            authwit_nonce,
+        ),
+    );
+}
+
+#[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, _) =
+        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;
+
+    // This should fail due to invalid ask token
+    let _order_id = env.call_private(
+        owner,
+        Orderbook::at(orderbook_address).create_order(
+            token0_address,
+            invalid_token,
+            bid_amount,
+            ask_amount,
+            authwit_nonce,
+        ),
+    );
+}
+
+#[test(should_fail_with = "SAME_TOKEN_TRADE")]
+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;
+
+    // This should fail due to same bid and ask tokens
+    let _order_id = env.call_private(
+        owner,
+        Orderbook::at(orderbook_address).create_order(
+            token0_address,
+            token0_address,
+            bid_amount,
+            ask_amount,
+            authwit_nonce,
+        ),
+    );
+}

yarn-project/end-to-end/src/e2e_orderbook.test.ts

@@ -9,9 +9,7 @@ import { setup } from './fixtures/utils.js';
 
 const TIMEOUT = 120_000;
 
-// TODO(#14525): Write thorough Orderbook tests. Currently we test only a happy path here because we will migrate these
-// tests to TXE once TXE 2.0 is ready. Didn't write it in TXE now as there is no way to obtain public events and all of
-// TXE will be rewritten soon.
+// Unhappy path tests are written only in Noir.
 describe('Orderbook', () => {
   jest.setTimeout(TIMEOUT);