feat: nft-contract

Nargo.toml

@@ -1,4 +1,5 @@
 [workspace]
 members = [
-"src/token_contract"
+"src/token_contract",
+"src/nft_contract"
 ]

src/nft_contract/Nargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "nft_contract"
+authors = [""]
+compiler_version = ">=1.0.0"
+type = "contract"
+
+[dependencies]
+aztec = { git = "https://github.com/AztecProtocol/aztec-packages/", tag = "v0.85.0", directory = "noir-projects/aztec-nr/aztec" }
+authwit = { git = "https://github.com/AztecProtocol/aztec-packages/", tag = "v0.85.0", directory = "noir-projects/aztec-nr/authwit" }
+compressed_string = { git = "https://github.com/AztecProtocol/aztec-packages/", tag = "v0.85.0", directory = "noir-projects/aztec-nr/compressed-string" }

src/nft_contract/src/test.nr

@@ -0,0 +1,14 @@
+mod access_control;
+mod mint_to_public;
+mod mint_to_private;
+mod burn_public;
+mod burn_private;
+mod initialize_transfer_commitment;
+mod transfer_private_to_commitment;
+mod transfer_private_to_private;
+mod transfer_private_to_public_with_commitment;
+mod transfer_private_to_public;
+mod transfer_public_to_private;
+mod transfer_public_to_public;
+mod utils;
+mod view;

src/nft_contract/src/test/access_control.nr

@@ -0,0 +1,19 @@
+use crate::NFT;
+use crate::test::utils;
+use aztec::{
+    oracle::{
+        execution::{get_block_number, get_contract_address},
+        storage::storage_read,
+    },
+    prelude::AztecAddress,
+    test::helpers::{cheatcodes, test_environment::TestEnvironment},
+};
+
+#[test]
+unconstrained fn nft_minter_is_set() {
+    let (env, nft_contract_address, owner, minter, recipient) = utils::setup_with_minter(false);
+    cheatcodes::set_contract_address(nft_contract_address);
+    let minter_slot = NFT::storage_layout().minter.slot;
+    let minter_address: AztecAddress = storage_read(nft_contract_address, minter_slot, get_block_number());
+    assert(minter_address == minter, "minter is not set");
+}

src/nft_contract/src/test/burn_private.nr

@@ -0,0 +1,142 @@
+use crate::NFT;
+use crate::test::utils;
+use authwit::cheatcodes as authwit_cheatcodes;
+use aztec::prelude::AztecAddress;
+
+#[test]
+unconstrained fn nft_burn_private_self_success() {
+    // Setup and mint NFT to owner in private state
+    let token_id = 10000;
+    let (env, nft_contract_address, owner, minter, recipient, token_id) = 
+        utils::setup_and_mint_to_private(false, token_id);
+
+    // Verify initial state
+    utils::assert_owns_private_nft(nft_contract_address, owner, token_id);
+    utils::assert_nft_exists(nft_contract_address, token_id);
+
+    // Burn the NFT
+    env.impersonate(owner);
+    NFT::at(nft_contract_address)
+        .burn_private(owner, token_id, 0)
+        .call(&mut env.private());
+    env.advance_block_by(1);
+
+    // Verify NFT is burned (no longer in private notes and marked as non-existent)
+    utils::assert_private_nft_nullified(nft_contract_address, owner, token_id);
+    utils::assert_nft_does_not_exist(nft_contract_address, token_id);
+}
+
+#[test]
+unconstrained fn nft_burn_private_authorized_success() {
+    // Setup with account contracts and mint NFT to owner
+    let token_id = 10000;
+    let (env, nft_contract_address, owner, minter, recipient, token_id) = 
+        utils::setup_and_mint_to_private(true, token_id);
+
+    // Verify initial state
+    utils::assert_owns_private_nft(nft_contract_address, owner, token_id);
+    utils::assert_nft_exists(nft_contract_address, token_id);
+
+    // Create burn call interface with non-zero nonce
+    let burn_call_interface = NFT::at(nft_contract_address)
+        .burn_private(owner, token_id, 1);
+
+    // Add authorization witness from owner to recipient
+    authwit_cheatcodes::add_private_authwit_from_call_interface(
+        owner,
+        recipient,
+        burn_call_interface,
+    );
+
+    // Impersonate recipient to perform the authorized burn
+    env.impersonate(recipient);
+    burn_call_interface.call(&mut env.private());
+    env.advance_block_by(1);
+
+    // Verify NFT is burned
+    utils::assert_private_nft_nullified(nft_contract_address, owner, token_id);
+    utils::assert_nft_does_not_exist(nft_contract_address, token_id);
+}
+
+#[test(should_fail_with = "invalid nonce")]
+unconstrained fn nft_burn_private_self_non_zero_nonce_fail() {
+    // Setup and mint NFT to owner
+    let token_id = 10000;
+    let (env, nft_contract_address, owner, minter, recipient, token_id) = 
+        utils::setup_and_mint_to_private(false, token_id);
+
+    // Attempt to burn with non-zero nonce as owner
+    env.impersonate(owner);
+    NFT::at(nft_contract_address)
+        .burn_private(owner, token_id, 1)
+        .call(&mut env.private());
+}
+
+#[test(should_fail_with = "nft not found in private to public")]
+unconstrained fn nft_burn_private_non_existent_fail() {
+    // Setup but don't mint any NFT
+    let (env, nft_contract_address, owner, minter, recipient) = utils::setup_with_minter(false);
+    let non_existent_token_id = 12345;
+
+    // Attempt to burn non-existent NFT
+    env.impersonate(owner);
+    NFT::at(nft_contract_address)
+        .burn_private(owner, non_existent_token_id, 0)
+        .call(&mut env.private());
+}
+
+#[test(should_fail_with = "Unknown auth witness for message hash")]
+unconstrained fn nft_burn_private_unauthorized_fail() {
+    // Setup with account contracts
+    let token_id = 10000;
+    let (env, nft_contract_address, owner, minter, recipient, token_id) = 
+        utils::setup_and_mint_to_private(true, token_id);
+
+    // Create burn interface with non-zero nonce
+    let burn_call_interface = NFT::at(nft_contract_address)
+        .burn_private(owner, token_id, 1);
+
+    // Impersonate recipient but DON'T add authorization witness
+    env.impersonate(recipient);
+    burn_call_interface.call(&mut env.private());
+}
+
+#[test(should_fail_with = "Unknown auth witness for message hash")]
+unconstrained fn nft_burn_private_wrong_authwit_fail() {
+    // Setup with account contracts
+    let token_id = 10000;
+    let (env, nft_contract_address, owner, minter, recipient, token_id) = 
+        utils::setup_and_mint_to_private(true, token_id);
+
+    // Create burn interface with non-zero nonce
+    let burn_call_interface = NFT::at(nft_contract_address)
+        .burn_private(owner, token_id, 1);
+
+    // Add authorization witness but to the wrong address (owner instead of recipient)
+    authwit_cheatcodes::add_private_authwit_from_call_interface(
+        owner,
+        owner,  // Wrong address - should be recipient
+        burn_call_interface,
+    );
+
+    // Impersonate recipient
+    env.impersonate(recipient);
+    burn_call_interface.call(&mut env.private());
+}
+
+#[test(should_fail_with = "nft not found in private to public")]
+unconstrained fn nft_burn_private_public_nft_fail() {
+    // Setup and mint NFT to owner in public state
+    let token_id = 10000;
+    let (env, nft_contract_address, owner, minter, recipient, token_id) = 
+        utils::setup_and_mint_to_public(false, token_id);
+
+    // Verify NFT is in public state
+    utils::assert_owns_public_nft(env, nft_contract_address, owner, token_id);
+
+    // Attempt to burn from private state when NFT is actually in public state
+    env.impersonate(owner);
+    NFT::at(nft_contract_address)
+        .burn_private(owner, token_id, 0)
+        .call(&mut env.private());
+}

src/nft_contract/src/test/burn_public.nr

@@ -0,0 +1,121 @@
+use crate::NFT;
+use crate::test::utils;
+use authwit::cheatcodes as authwit_cheatcodes;
+use aztec::prelude::AztecAddress;
+
+#[test]
+unconstrained fn nft_burn_public_success() {
+    // Setup and mint NFT to owner in public state
+    let token_id = 10000;
+    let (env, nft_contract_address, owner, minter, recipient, token_id) = 
+        utils::setup_and_mint_to_public(false, token_id);
+
+    // Verify initial state
+    utils::assert_owns_public_nft(env, nft_contract_address, owner, token_id);
+    utils::assert_nft_exists(nft_contract_address, token_id);
+
+    // Burn the NFT
+    env.impersonate(owner);
+    NFT::at(nft_contract_address)
+        .burn_public(owner, token_id, 0)
+        .call(&mut env.public());
+    env.advance_block_by(1);
+
+    // Verify NFT is burned (owner is zero address and NFT doesn't exist)
+    utils::assert_owns_public_nft(env, nft_contract_address, AztecAddress::zero(), token_id);
+    utils::assert_nft_does_not_exist(nft_contract_address, token_id);
+}
+
+#[test]
+unconstrained fn nft_burn_public_authorized_success() {
+    // Setup with account contracts and mint NFT to owner
+    let token_id = 10000;
+    let (env, nft_contract_address, owner, minter, recipient, token_id) = 
+        utils::setup_and_mint_to_public(true, token_id);
+
+    // Create burn call interface with non-zero nonce
+    let burn_call_interface = NFT::at(nft_contract_address)
+        .burn_public(owner, token_id, 1);
+
+    // Add authorization witness from owner to recipient
+    authwit_cheatcodes::add_public_authwit_from_call_interface(
+        owner,
+        recipient,
+        burn_call_interface,
+    );
+
+    // Impersonate recipient to perform the authorized burn
+    env.impersonate(recipient);
+    burn_call_interface.call(&mut env.public());
+    env.advance_block_by(1);
+
+    // Verify NFT is burned
+    utils::assert_owns_public_nft(env, nft_contract_address, AztecAddress::zero(), token_id);
+    utils::assert_nft_does_not_exist(nft_contract_address, token_id);
+}
+
+#[test(should_fail_with = "invalid nonce")]
+unconstrained fn nft_burn_public_self_non_zero_nonce_fail() {
+    // Setup and mint NFT to owner
+    let token_id = 10000;
+    let (env, nft_contract_address, owner, minter, recipient, token_id) = 
+        utils::setup_and_mint_to_public(false, token_id);
+
+    // Attempt to burn with non-zero nonce as owner
+    env.impersonate(owner);
+    NFT::at(nft_contract_address)
+        .burn_public(owner, token_id, 1)
+        .call(&mut env.public());
+}
+
+#[test(should_fail_with = "unauthorized")]
+unconstrained fn nft_burn_public_unauthorized_fail() {
+    // Setup with account contracts
+    let token_id = 10000;
+    let (env, nft_contract_address, owner, minter, recipient, token_id) = 
+        utils::setup_and_mint_to_public(true, token_id);
+
+    // Create burn interface with non-zero nonce
+    let burn_call_interface = NFT::at(nft_contract_address)
+        .burn_public(owner, token_id, 1);
+
+    // Impersonate recipient but DON'T add authorization witness
+    env.impersonate(recipient);
+    burn_call_interface.call(&mut env.public());
+}
+
+#[test(should_fail_with = "unauthorized")]
+unconstrained fn nft_burn_public_wrong_authwit_fail() {
+    // Setup with account contracts
+    let token_id = 10000;
+    let (env, nft_contract_address, owner, minter, recipient, token_id) = 
+        utils::setup_and_mint_to_public(true, token_id);
+
+    // Create burn interface with non-zero nonce
+    let burn_call_interface = NFT::at(nft_contract_address)
+        .burn_public(owner, token_id, 1);
+
+    // Add authorization witness but to the wrong address (owner instead of recipient)
+    authwit_cheatcodes::add_public_authwit_from_call_interface(
+        owner,
+        owner,  // Wrong address - should be recipient
+        burn_call_interface,
+    );
+
+    // Impersonate recipient
+    env.impersonate(recipient);
+    burn_call_interface.call(&mut env.public());
+}
+
+#[test(should_fail_with = "caller is not owner")]
+unconstrained fn nft_burn_public_non_existent_fail() {
+    // Setup but don't mint any NFT
+    let (env, nft_contract_address, owner, minter, recipient) = utils::setup_with_minter(false);
+    let non_existent_token_id = 12345;
+
+    // Attempt to burn non-existent NFT
+    env.impersonate(owner);
+    NFT::at(nft_contract_address)
+        .burn_public(owner, non_existent_token_id, 0)
+        .call(&mut env.public());
+}