use v2.0.2 contract source

critesjosh · critesjosh · commit 5bc8a6268a69 · 2025-09-19T11:52:44.000-04:00
diff --git a/scripts/deploy_contract.ts b/scripts/deploy_contract.ts
@@ -1,4 +1,4 @@
-import { EasyPrivateVotingContract } from "../src/artifacts/EasyPrivateVoting.js"
+import { PrivateVotingContract } from "../src/artifacts/PrivateVoting.js"
 import { createLogger, PXE, Logger, SponsoredFeePaymentMethod, Fr } from "@aztec/aztec.js";
 import { TokenContract } from "@aztec/noir-contracts.js/Token"
 import { setupPXE } from "../src/utils/setup_pxe.js";
@@ -23,7 +23,7 @@ async function main() {
     logger.info('💰 Setting up sponsored fee payment contract...');
     const sponsoredFPC = await getSponsoredFPCInstance();
     logger.info(`💰 Sponsored FPC instance obtained at: ${sponsoredFPC.address}`);
-    
+
     logger.info('📝 Registering sponsored FPC contract with PXE...');
     await pxe.registerContract({ instance: sponsoredFPC, artifact: SponsoredFPCContract.artifact });
     const sponsoredPaymentMethod = new SponsoredFeePaymentMethod(sponsoredFPC.address);
@@ -39,19 +39,19 @@ async function main() {
     // Deploy voting contract
     logger.info('🗳️  Starting voting contract deployment...');
     logger.info(`📋 Admin address for voting contract: ${address}`);
-    
-    const deployTx = EasyPrivateVotingContract.deploy(wallet, address).send({
+
+    const deployTx = PrivateVotingContract.deploy(wallet, address).send({
         from: wallet.getAddress(),
         fee: { paymentMethod: sponsoredPaymentMethod }
     });
-    
+
     logger.info('⏳ Waiting for deployment transaction to be mined...');
     const votingContract = await deployTx.deployed({ timeout: 120000 });
-    
+
     logger.info(`🎉 Voting Contract deployed successfully!`);
     logger.info(`📍 Contract address: ${votingContract.address}`);
     logger.info(`👤 Admin address: ${address}`);
-    
+
     // Verify deployment
     logger.info('🔍 Verifying contract deployment...');
     try {
@@ -61,11 +61,11 @@ async function main() {
             from: wallet.getAddress()
         });
         logger.info(`📊 Initial vote count for candidate 1: ${initialVoteCount}`);
-        
+
     } catch (error) {
         logger.error(`❌ Contract verification failed: ${error}`);
     }
-    
+
     logger.info('🏁 Deployment process completed successfully!');
     logger.info(`📋 Summary:`);
     logger.info(`   - Contract Address: ${votingContract.address}`);
diff --git a/scripts/fees.ts b/scripts/fees.ts
@@ -6,7 +6,7 @@ import { foundry } from 'viem/chains'
 import { mnemonicToAccount } from 'viem/accounts';
 import { FeeJuiceContract } from "@aztec/noir-contracts.js/FeeJuice";
 import { FPCContract } from "@aztec/noir-contracts.js/FPC";
-import { EasyPrivateVotingContract } from "../src/artifacts/EasyPrivateVoting.js"
+import { PrivateVotingContract } from "../src/artifacts/PrivateVoting.js"
 import { TokenContract } from "@aztec/noir-contracts.js/Token";
 // TODO: replace with import from aztec.js when published
 import { SponsoredFeePaymentMethod } from '@aztec/aztec.js/fee/testing'
@@ -67,7 +67,7 @@ async function main() {
     const paymentMethod = new SponsoredFeePaymentMethod(sponsoredFPC.address);
 
     // Two arbitrary txs to make the L1 message available on L2
-    const votingContract = await EasyPrivateVotingContract.deploy(wallet1, wallet1.getAddress()).send({
+    const votingContract = await PrivateVotingContract.deploy(wallet1, wallet1.getAddress()).send({
         from: wallet1.getAddress(),
         fee: { paymentMethod }
     }).deployed();
diff --git a/scripts/interaction_existing_contract.ts b/scripts/interaction_existing_contract.ts
@@ -1,5 +1,5 @@
 import { createLogger, Logger, SponsoredFeePaymentMethod, Fr, AztecAddress } from "@aztec/aztec.js";
-import { EasyPrivateVotingContract } from "../src/artifacts/EasyPrivateVoting.js";
+import { PrivateVotingContract } from "../src/artifacts/PrivateVoting.js";
 import { SponsoredFPCContract } from "@aztec/noir-contracts.js/SponsoredFPC";
 import { setupPXE } from "../src/utils/setup_pxe.js";
 import { getSponsoredFPCInstance } from "../src/utils/sponsored_fpc.js";
@@ -29,7 +29,7 @@ async function main() {
     }
 
     logger.info(`Connecting to voting contract at: ${contractAddress}`);
-    const votingContract = await EasyPrivateVotingContract.at(
+    const votingContract = await PrivateVotingContract.at(
         AztecAddress.fromString(contractAddress),
         wallet
     );
diff --git a/scripts/profile_deploy.ts b/scripts/profile_deploy.ts
@@ -1,4 +1,4 @@
-import { EasyPrivateVotingContract } from "../src/artifacts/EasyPrivateVoting.js"
+import { PrivateVotingContract } from "../src/artifacts/PrivateVoting.js"
 import { createLogger, PXE, Logger, SponsoredFeePaymentMethod, Fr } from "@aztec/aztec.js";
 import { setupPXE } from "../src/utils/setup_pxe.js";
 import { getSponsoredFPCInstance } from "../src/utils/sponsored_fpc.js";
@@ -21,7 +21,7 @@ async function main() {
     const wallet = await accountManager.getWallet();
     const address = await accountManager.getAddress();
 
-    const profileTx = await EasyPrivateVotingContract.deploy(wallet, address).profile({ profileMode: "full", from: address });
+    const profileTx = await PrivateVotingContract.deploy(wallet, address).profile({ profileMode: "full", from: address });
     console.dir(profileTx, { depth: 2 });
 }
 
diff --git a/src/main.nr b/src/main.nr
@@ -2,17 +2,17 @@ mod test;
 use dep::aztec::macros::aztec;
 
 #[aztec]
-pub contract EasyPrivateVoting {
+pub contract PrivateVoting {
     use dep::aztec::{
         keys::getters::get_public_keys,
         macros::{functions::{initializer, internal, private, public, utility}, storage::storage},
     };
-    use dep::aztec::state_vars::{Map, PublicImmutable, PublicMutable};
     use dep::aztec::protocol_types::{
-        address::{AztecAddress},
-        traits::ToField,
-        traits::Hash,
+        address::AztecAddress,
+        hash::poseidon2_hash,
+        traits::{Hash, ToField},
     };
+    use dep::aztec::state_vars::{Map, PublicImmutable, PublicMutable};
 
     #[storage]
     struct Storage<Context> {
@@ -34,12 +34,13 @@ pub contract EasyPrivateVoting {
     #[private]
     // annotation to mark function as private and expose private context
     fn cast_vote(candidate: Field) {
-        let msg_sender_npk_m_hash = get_public_keys(context.msg_sender()).npk_m.hash();
+        let msg_sender_nullifier_public_key_message_hash =
+            get_public_keys(context.msg_sender()).npk_m.hash();
 
-        let secret = context.request_nsk_app(msg_sender_npk_m_hash); // get secret key of caller of function
-        let nullifier = std::hash::pedersen_hash([context.msg_sender().to_field(), secret]); // derive nullifier from sender and secret
+        let secret = context.request_nsk_app(msg_sender_nullifier_public_key_message_hash); // get secret key of caller of function
+        let nullifier = poseidon2_hash([context.msg_sender().to_field(), secret]); // derive nullifier from sender and secret
         context.push_nullifier(nullifier);
-        EasyPrivateVoting::at(context.this_address()).add_to_tally_public(candidate).enqueue(
+        PrivateVoting::at(context.this_address()).add_to_tally_public(candidate).enqueue(
             &mut context,
         );
     }
diff --git a/src/test/e2e/accounts.test.ts b/src/test/e2e/accounts.test.ts
@@ -1,4 +1,4 @@
-import { EasyPrivateVotingContractArtifact, EasyPrivateVotingContract } from "../../artifacts/EasyPrivateVoting.js"
+import { PrivateVotingContractArtifact, PrivateVotingContract } from "../../artifacts/PrivateVoting.js"
 import { AccountManager, AccountWallet, ContractDeployer, createLogger, Fr, PXE, TxStatus, getContractInstanceFromInstantiationParams, Logger } from "@aztec/aztec.js";
 import { generateSchnorrAccounts } from "@aztec/accounts/testing"
 import { getSchnorrAccount } from '@aztec/accounts/schnorr';
@@ -114,11 +114,11 @@ describe("Accounts", () => {
         }
 
         // arbitrary transactions to progress 2 blocks, and have fee juice on Aztec ready to claim
-        await EasyPrivateVotingContract.deploy(ownerWallet, ownerWallet.getAddress()).send({
+        await PrivateVotingContract.deploy(ownerWallet, ownerWallet.getAddress()).send({
             from: ownerWallet.getAddress(),
             fee: { paymentMethod: sponsoredPaymentMethod }
         }).deployed(); // deploy contract with first funded wallet
-        await EasyPrivateVotingContract.deploy(ownerWallet, ownerWallet.getAddress()).send({
+        await PrivateVotingContract.deploy(ownerWallet, ownerWallet.getAddress()).send({
             from: ownerWallet.getAddress(),
             fee: { paymentMethod: sponsoredPaymentMethod }
         }).deployed(); // deploy contract with first funded wallet
@@ -153,7 +153,7 @@ describe("Accounts", () => {
 
     it("Sponsored contract deployment", async () => {
         const salt = Fr.random();
-        const VotingContractArtifact = EasyPrivateVotingContractArtifact
+        const VotingContractArtifact = PrivateVotingContractArtifact
         const accounts = await Promise.all(
             (await generateSchnorrAccounts(2)).map(
                 async a => await getSchnorrAccount(pxe, a.secret, a.signingKey, a.salt)
diff --git a/src/test/e2e/index.test.ts b/src/test/e2e/index.test.ts
@@ -1,4 +1,4 @@
-import { EasyPrivateVotingContractArtifact, EasyPrivateVotingContract } from "../../artifacts/EasyPrivateVoting.js"
+import { PrivateVotingContractArtifact, PrivateVotingContract } from "../../artifacts/PrivateVoting.js"
 import { AccountWallet, ContractDeployer, createLogger, Fr, PXE, TxStatus, getContractInstanceFromInstantiationParams, Logger, ContractInstanceWithAddress } from "@aztec/aztec.js";
 import { generateSchnorrAccounts } from "@aztec/accounts/testing"
 import { getSchnorrAccount } from '@aztec/accounts/schnorr';
@@ -62,7 +62,7 @@ describe("Voting", () => {
 
     it("Deploys the contract", async () => {
         const salt = Fr.random();
-        const VotingContractArtifact = EasyPrivateVotingContractArtifact
+        const VotingContractArtifact = PrivateVotingContractArtifact
         const accounts = await Promise.all(
             (await generateSchnorrAccounts(2)).map(
                 async a => await getSchnorrAccount(pxe, a.secret, a.signingKey, a.salt)
@@ -109,7 +109,7 @@ describe("Voting", () => {
     it("It casts a vote", async () => {
         const candidate = new Fr(1)
 
-        const contract = await EasyPrivateVotingContract.deploy(firstWallet, firstWallet.getAddress()).send({
+        const contract = await PrivateVotingContract.deploy(firstWallet, firstWallet.getAddress()).send({
             from: firstWallet.getAddress(),
             fee: { paymentMethod: sponsoredPaymentMethod }
         }).deployed();
@@ -126,7 +126,7 @@ describe("Voting", () => {
     it("It should fail when trying to vote twice", async () => {
         const candidate = new Fr(1)
 
-        const votingContract = await EasyPrivateVotingContract.deploy(firstWallet, firstWallet.getAddress()).send({
+        const votingContract = await PrivateVotingContract.deploy(firstWallet, firstWallet.getAddress()).send({
             from: firstWallet.getAddress(),
             fee: { paymentMethod: sponsoredPaymentMethod }
         }).deployed();
diff --git a/src/test/first.nr b/src/test/first.nr
@@ -1,105 +1,94 @@
 use crate::test::utils;
-use dep::aztec::oracle::{execution::get_block_number, storage::storage_read};
 use dep::aztec::protocol_types::storage::map::derive_storage_slot_in_map;
 
-use crate::EasyPrivateVoting;
+use crate::PrivateVoting;
 
 #[test]
 unconstrained fn test_initializer() {
-    let (_, voting_contract_address, admin) = utils::setup();
+    let (mut env, voting_contract_address, admin) = utils::setup();
 
-    let block_number = get_block_number();
-    let admin_slot = EasyPrivateVoting::storage_layout().admin.slot;
-    let admin_storage_value = storage_read(voting_contract_address, admin_slot, block_number);
-    assert(admin_storage_value == admin, "Admin should be correctly stored");
+    env.public_context_at(voting_contract_address, |context| {
+        let current_admin = context.storage_read(PrivateVoting::storage_layout().admin.slot);
+        assert_eq(current_admin, admin);
+    });
 }
 
 #[test]
 unconstrained fn test_check_vote_status() {
-    let (_, voting_contract_address, _) = utils::setup();
+    let (mut env, voting_contract_address, _) = utils::setup();
 
-    let vote_ended_expected: bool = false;
-
-    let block_number = get_block_number();
-    let status_slot = EasyPrivateVoting::storage_layout().vote_ended.slot;
-    let vote_ended_read: bool = storage_read(voting_contract_address, status_slot, block_number);
-    assert(vote_ended_expected == vote_ended_read, "Vote ended should be false");
+    env.public_context_at(voting_contract_address, |context| {
+        let vote_ended = context.storage_read(PrivateVoting::storage_layout().vote_ended.slot);
+        assert_eq(vote_ended, false);
+    });
 }
 
 #[test]
 unconstrained fn test_end_vote() {
     let (env, voting_contract_address, admin) = utils::setup();
 
-    env.call_public(admin, EasyPrivateVoting::at(voting_contract_address).end_vote());
-
-    let vote_ended_expected = true;
-
-    let block_number = get_block_number();
-    let status_slot = EasyPrivateVoting::storage_layout().vote_ended.slot;
-    let vote_ended_read: bool = storage_read(voting_contract_address, status_slot, block_number);
-    assert(vote_ended_expected == vote_ended_read, "Vote ended should be true");
+    env.call_public(admin, PrivateVoting::at(voting_contract_address).end_vote());
 
+    env.public_context_at(voting_contract_address, |context| {
+        let vote_ended = context.storage_read(PrivateVoting::storage_layout().vote_ended.slot);
+        assert_eq(vote_ended, true);
+    });
 }
 
-#[test(should_fail)]
+#[test(should_fail_with = "Only admin can end votes")]
 unconstrained fn test_fail_end_vote_by_non_admin() {
-    let (env, voting_contract_address, _) = utils::setup();
+    let (mut env, voting_contract_address, _) = utils::setup();
     let alice = env.create_light_account();
-    env.call_public(alice, EasyPrivateVoting::at(voting_contract_address).end_vote());
+
+    env.call_public(alice, PrivateVoting::at(voting_contract_address).end_vote());
 }
 
 #[test]
 unconstrained fn test_cast_vote() {
-    let (env, voting_contract_address, _) = utils::setup();
+    let (mut env, voting_contract_address, _) = utils::setup();
     let alice = env.create_light_account();
-    let candidate = 1;
-    env.call_private(alice, EasyPrivateVoting::at(voting_contract_address).cast_vote(candidate));
 
-    env.mine_block();
-
-    // Read vote count from storage
-    let block_number = get_block_number();
-    let tally_slot = EasyPrivateVoting::storage_layout().tally.slot;
-    let candidate_tally_slot = derive_storage_slot_in_map(tally_slot, candidate);
-    let vote_count: u32 = storage_read(voting_contract_address, candidate_tally_slot, block_number);
-
-    assert(vote_count == 1, "vote tally should be incremented");
+    let candidate = 1;
+    env.call_private(alice, PrivateVoting::at(voting_contract_address).cast_vote(candidate));
+
+    env.public_context_at(voting_contract_address, |context| {
+        let vote_count = context.storage_read(derive_storage_slot_in_map(
+            PrivateVoting::storage_layout().tally.slot,
+            candidate,
+        ));
+        assert_eq(vote_count, 1);
+    });
 }
 
 #[test]
 unconstrained fn test_cast_vote_with_separate_accounts() {
-    let (env, voting_contract_address, _) = utils::setup();
+    let (mut env, voting_contract_address, _) = utils::setup();
     let alice = env.create_light_account();
     let bob = env.create_light_account();
 
     let candidate = 101;
 
-    env.call_private(alice, EasyPrivateVoting::at(voting_contract_address).cast_vote(candidate));
-    env.mine_block();
-
-    env.call_private(bob, EasyPrivateVoting::at(voting_contract_address).cast_vote(candidate));
-    env.mine_block();
-    
+    env.call_private(alice, PrivateVoting::at(voting_contract_address).cast_vote(candidate));
 
-    // Read vote count from storage
-    let block_number = get_block_number();
-    let tally_slot = EasyPrivateVoting::storage_layout().tally.slot;
-    let candidate_tally_slot = derive_storage_slot_in_map(tally_slot, candidate);
-    let vote_count: u32 = storage_read(voting_contract_address, candidate_tally_slot, block_number);
+    let _ = env.call_private(bob, PrivateVoting::at(voting_contract_address).cast_vote(candidate));
 
-    assert(vote_count == 2, "vote tally should be 2");
+    env.public_context_at(voting_contract_address, |context| {
+        let vote_count = context.storage_read(derive_storage_slot_in_map(
+            PrivateVoting::storage_layout().tally.slot,
+            candidate,
+        ));
+        assert_eq(vote_count, 2);
+    });
 }
 
-#[test(should_fail)]
+#[test(should_fail_with = "already exists")]
 unconstrained fn test_fail_vote_twice() {
-    let (env, voting_contract_address, _) = utils::setup();
+    let (mut env, voting_contract_address, _) = utils::setup();
     let alice = env.create_light_account();
 
     let candidate = 101;
 
-    env.call_private(alice, EasyPrivateVoting::at(voting_contract_address).cast_vote(candidate));
-    env.mine_block();
+    env.call_private(alice, PrivateVoting::at(voting_contract_address).cast_vote(candidate));
 
-    // Vote again as alice
-    env.call_private(alice, EasyPrivateVoting::at(voting_contract_address).cast_vote(candidate));
+    env.call_private(alice, PrivateVoting::at(voting_contract_address).cast_vote(candidate));
 }
diff --git a/src/test/utils.nr b/src/test/utils.nr
@@ -1,21 +1,17 @@
 use dep::aztec::{
-    protocol_types::address::AztecAddress,
-    test::helpers::test_environment::TestEnvironment,
+    protocol_types::address::AztecAddress, test::helpers::test_environment::TestEnvironment,
 };
 
-use crate::EasyPrivateVoting;
+use crate::PrivateVoting;
 
-pub unconstrained fn setup() -> (&mut TestEnvironment, AztecAddress, AztecAddress) {
+pub unconstrained fn setup() -> (TestEnvironment, AztecAddress, AztecAddress) {
     let mut env = TestEnvironment::new();
 
-    let admin = env.create_contract_account();
+    let admin = env.create_light_account();
 
-    let initializer_call_interface = EasyPrivateVoting::interface().constructor(admin);
-    let voting_contract = env.deploy("EasyPrivateVoting").with_public_initializer(
-        admin,
-        initializer_call_interface,
-    );
+    let initializer_call_interface = PrivateVoting::interface().constructor(admin);
+    let voting_contract_address =
+        env.deploy("PrivateVoting").with_public_initializer(admin, initializer_call_interface);
 
-    env.mine_block();
-    (&mut env, voting_contract, admin)
+    (env, voting_contract_address, admin)
 }
