From 2f871ee9f385dec026cdb965b3dbe374b291f4e6 Mon Sep 17 00:00:00 2001 From: Rahul Kothari Date: Mon, 2 Oct 2023 11:50:58 +0100 Subject: [PATCH 1/4] feat(e2e): public flow for uniswap (#2596) Also added a `sender` address in the public flow, so like AC, anyone can swap on a user's behalf. Separate PR for failure cases that will be combined for both public and private! Trying to keep PRs small --- .../src/uniswap_trade_on_l1_from_l2.test.ts | 174 +++++++++++++++++- .../contracts/uniswap_contract/src/main.nr | 109 ++++++++++- .../contracts/uniswap_contract/src/util.nr | 65 +++++++ 3 files changed, 337 insertions(+), 11 deletions(-) diff --git a/yarn-project/end-to-end/src/uniswap_trade_on_l1_from_l2.test.ts b/yarn-project/end-to-end/src/uniswap_trade_on_l1_from_l2.test.ts index 4f25b6bbbc9..583a692b84e 100644 --- a/yarn-project/end-to-end/src/uniswap_trade_on_l1_from_l2.test.ts +++ b/yarn-project/end-to-end/src/uniswap_trade_on_l1_from_l2.test.ts @@ -39,6 +39,9 @@ describe('uniswap_trade_on_l1_from_l2', () => { let ownerWallet: AccountWallet; let ownerAddress: AztecAddress; let ownerEthAddress: EthAddress; + // does transactions on behalf of owner on Aztec: + let sponsorWallet: AccountWallet; + let sponsorAddress: AztecAddress; let daiCrossChainHarness: CrossChainTestHarness; let wethCrossChainHarness: CrossChainTestHarness; @@ -58,8 +61,8 @@ describe('uniswap_trade_on_l1_from_l2', () => { pxe: pxe_, deployL1ContractsValues, accounts, + wallets, logger: logger_, - wallet, cheatCodes, } = await setup(2, dumpedState); const walletClient = deployL1ContractsValues.walletClient; @@ -73,8 +76,10 @@ describe('uniswap_trade_on_l1_from_l2', () => { pxe = pxe_; logger = logger_; teardown = teardown_; - ownerWallet = wallet; + ownerWallet = wallets[0]; + sponsorWallet = wallets[1]; ownerAddress = accounts[0].address; + sponsorAddress = accounts[1].address; ownerEthAddress = EthAddress.fromString((await walletClient.getAddresses())[0]); logger('Deploying DAI Portal, initializing and deploying l2 contract...'); @@ -83,7 +88,7 @@ describe('uniswap_trade_on_l1_from_l2', () => { pxe, deployL1ContractsValues, accounts, - wallet, + ownerWallet, logger, cheatCodes, DAI_ADDRESS, @@ -95,7 +100,7 @@ describe('uniswap_trade_on_l1_from_l2', () => { pxe, deployL1ContractsValues, accounts, - wallet, + ownerWallet, logger, cheatCodes, WETH9_ADDRESS, @@ -110,7 +115,9 @@ describe('uniswap_trade_on_l1_from_l2', () => { publicClient, }); // deploy l2 uniswap contract and attach to portal - uniswapL2Contract = await UniswapContract.deploy(wallet).send({ portalContract: uniswapPortalAddress }).deployed(); + uniswapL2Contract = await UniswapContract.deploy(ownerWallet) + .send({ portalContract: uniswapPortalAddress }) + .deployed(); await uniswapL2Contract.attach(uniswapPortalAddress); await uniswapPortal.write.initialize( @@ -271,4 +278,161 @@ describe('uniswap_trade_on_l1_from_l2', () => { logger('WETH balance after swap : ', wethL2BalanceAfterSwap.toString()); logger('DAI balance after swap : ', daiL2BalanceAfterSwap.toString()); }, 140_000); + + it('should uniswap trade on L1 from L2 funds publicly (swaps WETH -> DAI)', async () => { + const wethL1BeforeBalance = await wethCrossChainHarness.getL1BalanceOf(ownerEthAddress); + + // 1. Approve and deposit weth to the portal and move to L2 + const [secretForMintingWeth, secretHashForMintingWeth] = await wethCrossChainHarness.generateClaimSecret(); + + const messageKey = await wethCrossChainHarness.sendTokensToPortalPublic( + wethAmountToBridge, + secretHashForMintingWeth, + ); + // funds transferred from owner to token portal + expect(await wethCrossChainHarness.getL1BalanceOf(ownerEthAddress)).toBe(wethL1BeforeBalance - wethAmountToBridge); + expect(await wethCrossChainHarness.getL1BalanceOf(wethCrossChainHarness.tokenPortalAddress)).toBe( + wethAmountToBridge, + ); + + // Wait for the archiver to process the message + await delay(5000); + + // Perform an unrelated transaction on L2 to progress the rollup. Here we transfer 0 tokens + await wethCrossChainHarness.mintTokensPublicOnL2(0n); + + // 2. Claim WETH on L2 + logger('Minting weth on L2'); + await wethCrossChainHarness.consumeMessageOnAztecAndMintPublicly( + wethAmountToBridge, + messageKey, + secretForMintingWeth, + ); + await wethCrossChainHarness.expectPublicBalanceOnL2(ownerAddress, wethAmountToBridge); + + // Store balances + const wethL2BalanceBeforeSwap = await wethCrossChainHarness.getL2PublicBalanceOf(ownerAddress); + const daiL2BalanceBeforeSwap = await daiCrossChainHarness.getL2PublicBalanceOf(ownerAddress); + + // 3. Owner gives uniswap approval to transfer funds on its behalf + const nonceForWETHTransferApproval = new Fr(2n); + const transferMessageHash = await hashPayload([ + uniswapL2Contract.address.toField(), + wethCrossChainHarness.l2Token.address.toField(), + FunctionSelector.fromSignature('transfer_public((Field),(Field),Field,Field)').toField(), + ownerAddress.toField(), + uniswapL2Contract.address.toField(), + new Fr(wethAmountToBridge), + nonceForWETHTransferApproval, + ]); + await ownerWallet.setPublicAuth(transferMessageHash, true).send().wait(); + + // 4. Swap on L1 - sends L2 to L1 message to withdraw WETH to L1 and another message to swap assets. + const deadlineForDepositingSwappedDai = BigInt(2 ** 32 - 1); // max uint32 - 1 + const [secretForDepositingSwappedDai, secretHashForDepositingSwappedDai] = + await daiCrossChainHarness.generateClaimSecret(); + + // 4.1 Owner approves user to swap on their behalf: + const nonceForSwap = new Fr(3n); + const swapMessageHash = await hashPayload([ + sponsorAddress.toField(), + uniswapL2Contract.address.toField(), + FunctionSelector.fromSignature( + 'swap_public((Field),(Field),Field,(Field),Field,Field,Field,(Field),Field,Field,(Field),(Field),Field)', + ).toField(), + ownerAddress.toField(), + wethCrossChainHarness.l2Bridge.address.toField(), + new Fr(wethAmountToBridge), + daiCrossChainHarness.l2Bridge.address.toField(), + nonceForWETHTransferApproval, + new Fr(uniswapFeeTier), + new Fr(minimumOutputAmount), + ownerAddress.toField(), + secretHashForDepositingSwappedDai, + new Fr(deadlineForDepositingSwappedDai), + ownerEthAddress.toField(), + ownerEthAddress.toField(), + nonceForSwap, + ]); + await ownerWallet.setPublicAuth(swapMessageHash, true).send().wait(); + + // 4.2 Call swap_public from user2 on behalf of owner + const withdrawReceipt = await uniswapL2Contract + .withWallet(sponsorWallet) + .methods.swap_public( + ownerAddress, + wethCrossChainHarness.l2Bridge.address, + wethAmountToBridge, + daiCrossChainHarness.l2Bridge.address, + nonceForWETHTransferApproval, + uniswapFeeTier, + minimumOutputAmount, + ownerAddress, + secretHashForDepositingSwappedDai, + deadlineForDepositingSwappedDai, + ownerEthAddress, + ownerEthAddress, + nonceForSwap, + ) + .send() + .wait(); + expect(withdrawReceipt.status).toBe(TxStatus.MINED); + + // check weth balance of owner on L2 (we first bridged `wethAmountToBridge` into L2 and now withdrew it!) + await wethCrossChainHarness.expectPublicBalanceOnL2(ownerAddress, wethL2BalanceBeforeSwap - wethAmountToBridge); + + // 5. Perform the swap on L1 with the `uniswapPortal.swap()` (consuming L2 to L1 messages) + logger('Execute withdraw and swap on the uniswapPortal!'); + const daiL1BalanceOfPortalBeforeSwap = await daiCrossChainHarness.getL1BalanceOf( + daiCrossChainHarness.tokenPortalAddress, + ); + const swapArgs = [ + wethCrossChainHarness.tokenPortalAddress.toString(), + wethAmountToBridge, + uniswapFeeTier, + daiCrossChainHarness.tokenPortalAddress.toString(), + minimumOutputAmount, + ownerAddress.toString(), + secretHashForDepositingSwappedDai.toString(true), + deadlineForDepositingSwappedDai, + ownerEthAddress.toString(), + true, + ] as const; + const { result: depositDaiMessageKeyHex } = await uniswapPortal.simulate.swapPublic(swapArgs, { + account: ownerEthAddress.toString(), + } as any); + + // this should also insert a message into the inbox. + await uniswapPortal.write.swapPublic(swapArgs, {} as any); + const depositDaiMessageKey = Fr.fromString(depositDaiMessageKeyHex); + // weth was swapped to dai and send to portal + const daiL1BalanceOfPortalAfter = await daiCrossChainHarness.getL1BalanceOf( + daiCrossChainHarness.tokenPortalAddress, + ); + expect(daiL1BalanceOfPortalAfter).toBeGreaterThan(daiL1BalanceOfPortalBeforeSwap); + const daiAmountToBridge = BigInt(daiL1BalanceOfPortalAfter - daiL1BalanceOfPortalBeforeSwap); + + // Wait for the archiver to process the message + await delay(5000); + // send a transfer tx to force through rollup with the message included + await wethCrossChainHarness.performL2Transfer(0n); + + // 6. claim dai on L2 + logger('Consuming messages to mint dai on L2'); + await daiCrossChainHarness.consumeMessageOnAztecAndMintPublicly( + daiAmountToBridge, + depositDaiMessageKey, + secretForDepositingSwappedDai, + ); + await daiCrossChainHarness.expectPublicBalanceOnL2(ownerAddress, daiL2BalanceBeforeSwap + daiAmountToBridge); + + const wethL2BalanceAfterSwap = await wethCrossChainHarness.getL2PublicBalanceOf(ownerAddress); + const daiL2BalanceAfterSwap = await daiCrossChainHarness.getL2PublicBalanceOf(ownerAddress); + + logger('WETH balance before swap: ', wethL2BalanceBeforeSwap.toString()); + logger('DAI balance before swap : ', daiL2BalanceBeforeSwap.toString()); + logger('***** 🧚‍♀️ SWAP L2 assets on L1 Uniswap 🧚‍♀️ *****'); + logger('WETH balance after swap : ', wethL2BalanceAfterSwap.toString()); + logger('DAI balance after swap : ', daiL2BalanceAfterSwap.toString()); + }, 140_000); }); diff --git a/yarn-project/noir-contracts/src/contracts/uniswap_contract/src/main.nr b/yarn-project/noir-contracts/src/contracts/uniswap_contract/src/main.nr index ccca6825078..2b01f224802 100644 --- a/yarn-project/noir-contracts/src/contracts/uniswap_contract/src/main.nr +++ b/yarn-project/noir-contracts/src/contracts/uniswap_contract/src/main.nr @@ -6,7 +6,7 @@ mod util; // Uses the token bridge contract, which tells which input token we need to talk to and handles the exit funds to L1 contract Uniswap { use dep::aztec::{ - auth::IS_VALID_SELECTOR, + auth::{IS_VALID_SELECTOR, assert_valid_public_message_for}, context::{PrivateContext, PublicContext, Context}, oracle::compute_selector::compute_selector, oracle::context::get_portal_address, @@ -21,7 +21,7 @@ contract Uniswap { }; use crate::interfaces::{Token, TokenBridge}; - use crate::util::{compute_message_hash, compute_swap_private_content_hash}; + use crate::util::{compute_message_hash, compute_swap_private_content_hash, compute_swap_public_content_hash}; struct Storage { // like with account contracts, stores the approval message on a slot and tracks if they are active @@ -49,6 +49,96 @@ contract Uniswap { #[aztec(private)] fn constructor() {} + #[aztec(public)] + fn swap_public( + sender: AztecAddress, + input_asset_bridge: AztecAddress, + input_amount: Field, + output_asset_bridge: AztecAddress, + // params for using the transfer approval + nonce_for_transfer_approval: Field, + // params for the swap + uniswap_fee_tier: Field, + minimum_output_amount: Field, + // params for the depositing output_asset back to Aztec + recipient: AztecAddress, + secret_hash_for_L1_to_l2_message: Field, + deadline_for_L1_to_l2_message: Field, + canceller_for_L1_to_L2_message: EthereumAddress, + caller_on_L1: EthereumAddress, + // nonce for someone to call swap on sender's behalf + nonce_for_swap_approval: Field, + ) -> Field { + + if (sender.address != context.msg_sender()) { + // if someone else is calling on swap on sender's behalf, they need to have authorisation to do so: + let selector = compute_selector( + "swap_public((Field),(Field),Field,(Field),Field,Field,Field,(Field),Field,Field,(Field),(Field),Field)" + ); + let message_field = compute_message_hash([ + context.msg_sender(), + context.this_address(), + selector, + sender.address, + input_asset_bridge.address, + input_amount, + output_asset_bridge.address, + nonce_for_transfer_approval, + uniswap_fee_tier, + minimum_output_amount, + recipient.address, + secret_hash_for_L1_to_l2_message, + deadline_for_L1_to_l2_message, + canceller_for_L1_to_L2_message.address, + caller_on_L1.address, + nonce_for_swap_approval, + ]); + // this also emits a nullifier for the message + assert_valid_public_message_for(&mut context,sender.address,message_field); + } + + let input_asset = AztecAddress::new(TokenBridge::at(input_asset_bridge.address).token(context)); + + // Transfer funds to this contract + Token::at(input_asset.address).transfer_public( + context, + sender.address, + context.this_address(), + input_amount, + nonce_for_transfer_approval, + ); + + // Approve bridge to burn this contract's funds and exit to L1 Uniswap Portal + let _void = context.call_public_function( + context.this_address(), + compute_selector("_approve_bridge_and_exit_input_asset_to_L1((Field),(Field),Field)"), + [input_asset.address, input_asset_bridge.address, input_amount], + ); + + // Create swap message and send to Outbox for Uniswap Portal + // this ensures the integrity of what the user originally intends to do on L1. + let input_asset_bridge_portal_address = get_portal_address(input_asset_bridge.address); + let output_asset_bridge_portal_address = get_portal_address(output_asset_bridge.address); + assert(input_asset_bridge_portal_address != 0, "L1 portal address of input_asset's bridge is 0"); + assert(output_asset_bridge_portal_address != 0, "L1 portal address of output_asset's bridge is 0"); + + let content_hash = compute_swap_public_content_hash( + input_asset_bridge_portal_address, + input_amount, + uniswap_fee_tier, + output_asset_bridge_portal_address, + minimum_output_amount, + recipient.address, + secret_hash_for_L1_to_l2_message, + deadline_for_L1_to_l2_message, + canceller_for_L1_to_L2_message.address, + caller_on_L1.address, + ); + context.message_portal(content_hash); + + 1 + } + #[aztec(private)] fn swap( input_asset: AztecAddress, // since private, we pass here and later assert that this is as expected by input_bridge @@ -68,6 +158,10 @@ contract Uniswap { caller_on_L1: EthereumAddress, // ethereum address that can call this function on the L1 portal (0x0 if anyone can call) ) -> Field { + // Assert that user provided token address is same as expected by token bridge. + // we can't directly use `input_asset_bridge.token` because that is a public method and public can't return data to private + context.call_public_function(context.this_address(), compute_selector("_assert_token_is_same(Field,Field)"), [input_asset.address, input_asset_bridge.address]); + // Transfer funds to this contract Token::at(input_asset.address).unshield( &mut context, @@ -122,7 +216,8 @@ contract Uniswap { } // This helper method approves the bridge to burn this contract's funds and exits the input asset to L1 - // Assumes contract already has funds + // Assumes contract already has funds. + // Assume `token` relates to `token_bridge` (ie token_bridge.token == token) // Note that private can't read public return values so created an internal public that handles everything // this method is used for both private and public swaps. #[aztec(public)] @@ -131,9 +226,6 @@ contract Uniswap { token_bridge: AztecAddress, amount: Field, ) { - // Assert that user provided token address is same as expected by token bridge. - assert(token.address == (TokenBridge::at(token_bridge.address).token(context)), "input_asset address is not the same as seen in the bridge contract"); - // approve bridge to burn this contract's funds (required when exiting on L1, as it burns funds on L2): let nonce_for_burn_approval = storage.nonce_for_burn_approval.read(); let selector = compute_selector("burn_public((Field),Field,Field)"); @@ -152,4 +244,9 @@ contract Uniswap { nonce_for_burn_approval, ); } + + #[aztec(public)] + internal fn _assert_token_is_same(token: Field, token_bridge: Field) { + assert(token == (TokenBridge::at(token_bridge).token(context)), "input_asset address is not the same as seen in the bridge contract"); + } } \ No newline at end of file diff --git a/yarn-project/noir-contracts/src/contracts/uniswap_contract/src/util.nr b/yarn-project/noir-contracts/src/contracts/uniswap_contract/src/util.nr index da1361ab8e3..4e578587e4a 100644 --- a/yarn-project/noir-contracts/src/contracts/uniswap_contract/src/util.nr +++ b/yarn-project/noir-contracts/src/contracts/uniswap_contract/src/util.nr @@ -71,3 +71,68 @@ fn compute_swap_private_content_hash( content_hash } + +// This method computes the L2 to L1 message content hash for the public +// refer `l1-contracts/test/portals/UniswapPortal.sol` on how L2 to L1 message is expected +fn compute_swap_public_content_hash( + input_asset_bridge_portal_address: Field, + input_amount: Field, + uniswap_fee_tier: Field, + output_asset_bridge_portal_address: Field, + minimum_output_amount: Field, + aztec_recipient: Field, + secret_hash_for_L1_to_l2_message: Field, + deadline_for_L1_to_l2_message: Field, + canceller_for_L1_to_L2_message: Field, + caller_on_L1: Field, +) -> Field { + let mut hash_bytes: [u8; 324] = [0; 324]; // 10 fields of 32 bytes each + 4 bytes fn selector + + let input_token_portal_bytes = input_asset_bridge_portal_address.to_be_bytes(32); + let in_amount_bytes = input_amount.to_be_bytes(32); + let uniswap_fee_tier_bytes = uniswap_fee_tier.to_be_bytes(32); + let output_token_portal_bytes = output_asset_bridge_portal_address.to_be_bytes(32); + let amount_out_min_bytes = minimum_output_amount.to_be_bytes(32); + let aztec_recipient_bytes = aztec_recipient.to_be_bytes(32); + let secret_hash_for_L1_to_l2_message_bytes = secret_hash_for_L1_to_l2_message.to_be_bytes(32); + let deadline_for_L1_to_l2_message_bytes = deadline_for_L1_to_l2_message.to_be_bytes(32); + let canceller_bytes = canceller_for_L1_to_L2_message.to_be_bytes(32); + let caller_on_L1_bytes = caller_on_L1.to_be_bytes(32); + + // function selector: 0xf3068cac keccak256("swap_public(address,uint256,uint24,address,uint256,bytes32,bytes32,uint32,address,address)") + hash_bytes[0] = 0xf3; + hash_bytes[1] = 0x06; + hash_bytes[2] = 0x8c; + hash_bytes[3] = 0xac; + + for i in 0..32 { + hash_bytes[i + 4] = input_token_portal_bytes[i]; + hash_bytes[i + 36] = in_amount_bytes[i]; + hash_bytes[i + 68] = uniswap_fee_tier_bytes[i]; + hash_bytes[i + 100] = output_token_portal_bytes[i]; + hash_bytes[i + 132] = amount_out_min_bytes[i]; + hash_bytes[i + 164] = aztec_recipient_bytes[i]; + hash_bytes[i + 196] = secret_hash_for_L1_to_l2_message_bytes[i]; + hash_bytes[i + 228] = deadline_for_L1_to_l2_message_bytes[i]; + hash_bytes[i + 260] = canceller_bytes[i]; + hash_bytes[i + 292] = caller_on_L1_bytes[i]; + } + + let content_sha256 = sha256(hash_bytes); + + // Convert the content_sha256 to a field element + let mut v = 1; + let mut high = 0 as Field; + let mut low = 0 as Field; + + for i in 0..16 { + high = high + (content_sha256[15 - i] as Field) * v; + low = low + (content_sha256[16 + 15 - i] as Field) * v; + v = v * 256; + } + + // Abuse that a % p + b % p = (a + b) % p and that low < p + let content_hash = low + high * v; + + content_hash +} From d225d56d2e48a84c0c8854fc033b6aad48a1f66e Mon Sep 17 00:00:00 2001 From: Leila Wang Date: Mon, 2 Oct 2023 13:41:52 +0200 Subject: [PATCH 2/4] feat: deprecate assert_contains_and_remove (#2594) Please provide a paragraph or two giving a summary of the change, including relevant motivation and context. # Checklist: Remove the checklist to signal you've completed it. Enable auto-merge if the PR is ready to merge. - [ ] If the pull request requires a cryptography review (e.g. cryptographic algorithm implementations) I have added the 'crypto' tag. - [ ] I have reviewed my diff in github, line by line and removed unexpected formatting changes, testing logs, or commented-out code. - [ ] Every change is related to the PR description. - [ ] I have [linked](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue) this pull request to relevant issues (if any exist). --- .../docs/dev_docs/contracts/syntax/storage.md | 67 ++++-------- .../dev_docs/getting_started/quickstart.md | 3 +- .../tutorials/writing_token_contract.md | 2 +- .../acir-simulator/src/acvm/oracle/oracle.ts | 51 +++++---- .../src/acvm/oracle/typed_oracle.ts | 4 - .../src/client/client_execution_context.ts | 49 +-------- .../src/client/execution_note_cache.ts | 2 +- .../src/client/private_execution.test.ts | 96 ++++++----------- .../src/client/view_data_oracle.ts | 21 +--- .../src/public/public_execution_context.ts | 25 +---- .../aztec-nr/aztec/src/note/lifecycle.nr | 7 +- .../aztec-nr/aztec/src/note/note_getter.nr | 28 ----- .../aztec-nr/aztec/src/note/note_header.nr | 9 +- yarn-project/aztec-nr/aztec/src/note/utils.nr | 9 +- .../aztec-nr/aztec/src/oracle/notes.nr | 29 ++--- .../aztec-nr/aztec/src/state_vars/set.nr | 73 ++----------- .../src/abis/ecdsa_account_contract.json | 6 +- .../src/abis/schnorr_account_contract.json | 6 +- yarn-project/aztec.js/src/index.ts | 1 + .../aztec.js/src/wallet/base_wallet.ts | 13 ++- .../src/artifacts/private_token_contract.json | 100 +++++++++--------- .../private-token/src/contracts/src/main.nr | 2 +- yarn-project/canary/package.json | 2 +- .../src/uniswap_trade_on_l1_from_l2.test.ts | 32 +++++- yarn-project/cli/src/index.ts | 18 ++++ yarn-project/cli/src/utils.ts | 41 +++++++ yarn-project/end-to-end/src/canary/browser.ts | 13 ++- yarn-project/end-to-end/src/canary/cli.ts | 9 ++ .../end-to-end/src/e2e_2_pxes.test.ts | 22 ++-- .../src/e2e_cross_chain_messaging.test.ts | 5 + .../src/e2e_escrow_contract.test.ts | 34 ++++-- .../src/e2e_lending_contract.test.ts | 9 +- .../e2e_multiple_accounts_1_enc_key.test.ts | 17 ++- .../src/e2e_private_airdrop.test.ts | 8 +- .../src/e2e_sandbox_example.test.ts | 14 ++- .../end-to-end/src/e2e_token_contract.test.ts | 36 +++---- .../src/fixtures/cross_chain_test_harness.ts | 17 ++- .../src/guides/dapp_testing.test.ts | 60 ++++++++--- .../end-to-end/src/guides/up_quick_start.sh | 10 +- .../writing_an_account_contract.test.ts | 11 +- .../end-to-end/src/sample-dapp/index.mjs | 8 +- .../end-to-end/src/sample-dapp/index.test.mjs | 9 +- .../contracts/card_game_contract/src/main.nr | 2 +- .../docs_example_contract/src/actions.nr | 10 -- .../src/types/profile_note.nr | 1 - .../src/types/rules_note.nr | 1 - .../easy_private_token_contract/src/main.nr | 2 +- .../ecdsa_account_contract/src/main.nr | 2 +- .../src/contracts/escrow_contract/src/main.nr | 2 +- .../non_native_token_contract/src/main.nr | 14 ++- .../pending_commitments_contract/src/main.nr | 2 +- .../pokeable_token_contract/src/main.nr | 2 +- .../src/interface.nr | 10 +- .../src/main.nr | 35 ++---- .../private_token_contract/src/main.nr | 4 +- .../schnorr_account_contract/src/main.nr | 2 +- .../stateful_test_contract/src/main.nr | 2 +- .../src/contracts/token_contract/src/main.nr | 14 +-- .../pxe/src/pxe_service/pxe_service.ts | 30 ++++-- yarn-project/types/src/interfaces/pxe.ts | 11 +- 60 files changed, 557 insertions(+), 567 deletions(-) diff --git a/docs/docs/dev_docs/contracts/syntax/storage.md b/docs/docs/dev_docs/contracts/syntax/storage.md index 4bac605a736..fc5c06c831a 100644 --- a/docs/docs/dev_docs/contracts/syntax/storage.md +++ b/docs/docs/dev_docs/contracts/syntax/storage.md @@ -2,7 +2,7 @@ title: Storage --- -In an Aztec.nr contract, storage is to be defined as a single struct, that contains both public and private state variables. +In an Aztec.nr contract, storage is to be defined as a single struct, that contains both public and private state variables. As their name indicates, public state variables can be read by anyone, while private state variables can only be read by their owner, or people whom the owner has shared the data with. @@ -82,12 +82,12 @@ To define that a variable is public, it is wrapped in the `PublicState` struct, #include_code public_state_struct /yarn-project/aztec-nr/aztec/src/state_vars/public_state.nr rust -The `PublicState` struct is generic over the variable type `T` and its serialized size `T_SERIALIZED_LEN`. +The `PublicState` struct is generic over the variable type `T` and its serialized size `T_SERIALIZED_LEN`. :::info Currently, the length of the types must be specified when declaring the storage struct but the intention is that this will be inferred in the future. ::: -The struct contains a `storage_slot` which, similar to Ethereum, is used to figure out *where* in storage the variable is located. Notice that while we don't have the exact same [state model](./../../../concepts/foundation/state_model.md) as EVM chains it will look similar from the contract developers point of view. +The struct contains a `storage_slot` which, similar to Ethereum, is used to figure out _where_ in storage the variable is located. Notice that while we don't have the exact same [state model](./../../../concepts/foundation/state_model.md) as EVM chains it will look similar from the contract developers point of view. Beyond the struct, the `PublicState` also contains `serialization_methods`, which is a struct with methods that instruct the `PublicState` how to serialize and deserialize the variable. @@ -101,17 +101,18 @@ The Aztec.nr library provides serialization methods for various common types. As #include_code field_serialization /yarn-project/aztec-nr/aztec/src/types/type_serialization/field_serialization.nr rust - :::info An example using a larger struct can be found in the [lending example](https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/noir-contracts/src/contracts/lending_contract)'s use of an [`Asset`](https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/noir-contracts/src/contracts/lending_contract/src/asset.nr). ::: ### `new` + When declaring the storage for `T` as a persistent public storage variable, we use the `PublicState::new()` constructor. As seen below, this takes the `storage_slot` and the `serialization_methods` as arguments along with the [`Context`](./context.mdx), which in this case is used to share interface with other structures. #include_code public_state_struct_new /yarn-project/aztec-nr/aztec/src/state_vars/public_state.nr rust #### Single value example + Say that we wish to add `admin` public state variable into our storage struct. In the struct we can add it as follows: #include_code storage_admin /yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr rust @@ -121,14 +122,17 @@ And then when initializing it in the `Storage::init` function we can do it as fo #include_code storage_admin_init /yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr rust In this case, specifying that we are dealing with a Field, and that it should be put at slot 1. This is just a single value, and would be similar to the following in solidity: + ```solidity address internal admin; ``` + :::info We know its verbose, and are working on making it less so. ::: #### Mapping example + Say we want to have a group of `minters` that are able to mint assets in our contract, and we want them in public storage, because [access control in private is quite cumbersome](./../../../concepts/foundation/communication/public_private_calls.md#a-note-on-l2-access-control). In the `Storage` struct we can add it as follows: #include_code storage_minters /yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr rust @@ -140,13 +144,14 @@ And then when initializing it in the `Storage::init` function we can do it as fo In this case, specifying that we are dealing with a map of Fields, and that it should be put at slot 2. This would be similar to the following in solidity: + ```solidity mapping(address => bool) internal minters; ``` ### `read` -Now we have an idea of how to define storage, but storage is not really useful before we start using it, so how can we access it? +Now we have an idea of how to define storage, but storage is not really useful before we start using it, so how can we access it? Reading data from storage is straightforward. On the `PublicState` structs we have a `read` method to read the value at the location in storage and using the specified deserialization method to deserialize it. Here is the function definition in the `public_state.nr` source: @@ -158,17 +163,15 @@ For our `admin` example from earlier, this could be used as follows to check tha #include_code read_admin /yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr rust - #### Reading from our `minters` example -As we saw in the Map earlier, a very similar operation can be done to perform a lookup in a map. +As we saw in the Map earlier, a very similar operation can be done to perform a lookup in a map. #include_code read_minter /yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr rust - ### `write` -We figured out how to read values, but how do we write them? +We figured out how to read values, but how do we write them? Like reading, it is actually quite straight-forward. We have a `write` method on the `PublicState` struct that takes the value to write as an input and saves this in storage. It uses the serialization method defined earlier to serialize the value which inserts (possibly multiple) values into storage. @@ -183,6 +186,7 @@ Like reading, it is actually quite straight-forward. We have a `write` method on #include_code write_minter /yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr rust ## Private State Variables + In contrast to public state, private state is persistent state that is **not** visible to the whole world. Depending on the logic of the smart contract, a private state variable's current value will only be known to one entity, or a closed group of entities. The value of a private state variable can either be shared via an [encrypted log](./events.md#encrypted-events), or offchain via web2, or completely offline: it's up to the app developer. @@ -201,7 +205,8 @@ These three structs abstract-away many of Aztec's protocol complexities, by prov Note that an app can also choose to emit data via unencrypted log, or to define a note whose data is easy to figure out, then the information is technically not private and could be visible to anyone. ::: -### Notes +### Notes + Unlike public state variables, which can be arbitrary types, private state variables operate on `NoteType`. Notes are the fundamental elements in the private world. @@ -226,9 +231,6 @@ The interplay between a private state variable and its notes can be confusing. H - To modify the "current value" of a `Set` state variable, is to [`insert`](#insert) new notes into the `Set`, or [`remove`](#remove) notes from that set. - Interestingly, if a developer requires a private state to be modifiable by users who _aren't_ privy to the value of that state, a `Set` is a very useful type. The `insert` method allows new notes to be added to the `Set` without knowing any of the other notes in the set! (Like posting an envelope into a post box, you don't know what else is in there!). - - - ## `Singleton` Singleton is a private state variable that is unique in a way. When a Singleton is initialized, a note is created to represent its value. And the way to update the value is to destroy the current note, and create a new one with the updated value. @@ -289,7 +291,7 @@ However, it's possible that at the time this function is called, the system hasn ImmutableSingleton represents a unique private state variable that, as the name suggests, is immutable. Once initialized, its value cannot be altered. -#include_code struct /yarn-project/aztec-nr/aztec/src/state_vars/immutable_singleton.nr rust +#include_code struct /yarn-project/aztec-nr/aztec/src/state_vars/immutable_singleton.nr rust ### `new` @@ -313,9 +315,9 @@ Once initialized, an ImmutableSingleton's value remains unchangeable. This metho Similar to the `Singleton`, we can use the `get_note` method to read the value of an ImmutableSingleton. -#include_code get_note /yarn-project/aztec-nr/aztec/src/state_vars/immutable_singleton.nr rust +#include_code get_note /yarn-project/aztec-nr/aztec/src/state_vars/immutable_singleton.nr rust -Use this method to retrieve the value of an initialized ImmutableSingleton. +Use this method to retrieve the value of an initialized ImmutableSingleton. #include_code get_note /yarn-project/noir-contracts/src/contracts/schnorr_account_contract/src/main.nr rust @@ -327,7 +329,7 @@ This function will throw if the ImmutableSingleton hasn't been initialized. Set is used for managing a collection of notes. All notes in a set are of the same `NoteType`. But whether these notes all belong to one entity, or are accessible and editable by different entities, is totally up to the developer. Due to our state model, the set is a collection of notes inserted into the data-tree, but notes are never removed from the tree itself, they are only nullified. -#include_code struct /yarn-project/aztec-nr/aztec/src/state_vars/set.nr rust +#include_code struct /yarn-project/aztec-nr/aztec/src/state_vars/set.nr rust And can be added to the `Storage` struct as follows. Here adding a set for a custom note, the TransparentNote (useful for [public -> private communication](./functions.md#public---private)). @@ -363,33 +365,9 @@ The usage is rather straight-forward and very similar to using the `insert` meth #include_code insert_from_public /yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr rust -### `assert_contains_and_remove` - -This function is used to check existence of a note and then remove it without having read the note ahead of time. This can be useful for cases where the user is providing all the information needed, such as cases where the note was never emitted to the network and thereby available to the wallet. - -#include_code assert_contains_and_remove /yarn-project/aztec-nr/aztec/src/state_vars/set.nr rust - - - -### `assert_contains_and_remove_publicly_created` - -Like above, this is used to ensure that the message exists in the data tree and then consume it. However, it differs slightly since there is currently a difference between notes that have been inserted from public and private execution. This means that you currently must use this function to consume and nullify a note that was created in a public function. This will be fixed in the future. - -#include_code assert_contains_and_remove_publicly_created /yarn-project/aztec-nr/aztec/src/state_vars/set.nr rust - -While this might look intimidating, the use of the function is rather easy, and is used in the following way: - -#include_code assert_contains_and_remove_publicly_created /yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr rust - -The reason we are not reading this note ahead of time is that no [encrypted log](./events.md#encrypted-events) was emitted for this note, since it was created in public thereby making the encrypted log useless (everyone saw the content ahead of time). - ### `remove` -Will remove a note from the set if it previously has been read from storage, e.g. you have fetched it through a `get_notes` call. This is useful when you want to remove a note that you have previously read from storage and do not have to read it again. If you recall from earlier, we are emitting a nullifier when reading values to make sure that they are up to date. +Will remove a note from the set if it previously has been read from storage, e.g. you have fetched it through a `get_notes` call. This is useful when you want to remove a note that you have previously read from storage and do not have to read it again. If you recall from earlier, we are emitting a nullifier when reading values to make sure that they are up to date. #include_code remove /yarn-project/aztec-nr/aztec/src/state_vars/set.nr rust @@ -403,15 +381,16 @@ This function returns the notes the account has access to: #include_code get_notes /yarn-project/aztec-nr/aztec/src/state_vars/set.nr rust -Our kernel circuits are constrained to a maximum number of notes this function can return at a time. Check [here](https://github.com/AztecProtocol/aztec-packages/blob/master/yarn-project/aztec-nr/aztec/src/constants_gen.nr) and look for `MAX_READ_REQUESTS_PER_CALL` for the up-to-date number. +Our kernel circuits are constrained to a maximum number of notes this function can return at a time. Check [here](https://github.com/AztecProtocol/aztec-packages/blob/master/yarn-project/aztec-nr/aztec/src/constants_gen.nr) and look for `MAX_READ_REQUESTS_PER_CALL` for the up-to-date number. Because of this limit, we should always consider using the second argument `NoteGetterOptions` to limit the number of notes we need to read and constrain in our programs. This is quite important as every extra call increases the time used to prove the program and we don't want to spend more time than necessary. -An example of such options is using the [filter_notes_min_sum](https://github.com/AztecProtocol/aztec-packages/blob/master/yarn-project/aztec-nr/value-note/src/filter.nr) to get "enough" notes to cover a given value. Essentially, this function will return just enough notes to cover the amount specified such that we don't need to read all our notes. For users with a lot of notes, this becomes increasingly important. +An example of such options is using the [filter_notes_min_sum](https://github.com/AztecProtocol/aztec-packages/blob/master/yarn-project/aztec-nr/value-note/src/filter.nr) to get "enough" notes to cover a given value. Essentially, this function will return just enough notes to cover the amount specified such that we don't need to read all our notes. For users with a lot of notes, this becomes increasingly important. #include_code get_notes /yarn-project/aztec-nr/easy-private-state/src/easy_private_state.nr rust ### `view_notes` + Functionally similar to [`get_notes`](#get_notes), but executed unconstrained and can be used by the wallet to fetch notes for use by front-ends etc. #include_code view_notes /yarn-project/aztec-nr/aztec/src/state_vars/set.nr rust diff --git a/docs/docs/dev_docs/getting_started/quickstart.md b/docs/docs/dev_docs/getting_started/quickstart.md index 48735d70aa0..74c147d8729 100644 --- a/docs/docs/dev_docs/getting_started/quickstart.md +++ b/docs/docs/dev_docs/getting_started/quickstart.md @@ -97,7 +97,7 @@ Note that the deployed contract address is exported, so we can use it as `$CONTR Alice is set up as the contract admin and token minter in the `_initialize` function. Let's get Alice some private tokens. -We need to export the `SECRET` and `SECRET_HASH` values in order to privately mint tokens. Private tokens are claimable by anyone with the pre-image to a provided hash, see more about how the token contract works in the [token contract tutorial](../tutorials/writing_token_contract.md). Once the tokens have been minted, Alice can claim them with the `redeem_shield` function. After this, Alice should have 1000 tokens in their private balance. +We need to export the `SECRET` and `SECRET_HASH` values in order to privately mint tokens. Private tokens are claimable by anyone with the pre-image to a provided hash, see more about how the token contract works in the [token contract tutorial](../tutorials/writing_token_contract.md). After the tokens have been minted, the notes will have to added to the PXE to be consumed by private functions. Once added, Alice can claim them with the `redeem_shield` function. After this, Alice should have 1000 tokens in their private balance. #include_code mint-private yarn-project/end-to-end/src/guides/up_quick_start.sh bash @@ -117,4 +117,3 @@ Aztec's Layer 2 network is a fully programmable combined private/public ZK rollu - Private Execution Environment (PXE) - Normally residing with the end client, this decrypts and stores a client's private state, executes simulations and submits transactions to the Aztec Node. - [Aztec.js](./sandbox) - Aztec's client library for interacting with the PXE (think Ethers.js). - [Aztec.nr](../contracts/main.md) - Aztec's smart contract framework - diff --git a/docs/docs/dev_docs/tutorials/writing_token_contract.md b/docs/docs/dev_docs/tutorials/writing_token_contract.md index ef6f9b840f4..872fe819aba 100644 --- a/docs/docs/dev_docs/tutorials/writing_token_contract.md +++ b/docs/docs/dev_docs/tutorials/writing_token_contract.md @@ -378,7 +378,7 @@ Storage is referenced as `storage.variable`. This private function enables an account to move tokens from a `TransparentNote` in the `pending_shields` mapping to any Aztec account as a `ValueNote` in private `balances`. -Going through the function logic, first storage is initialized. Then it gets the private balance for the recipient. A `TransparentNote` is created from the `amount` and `secret` and verified to exist storage in `pending_shields` with the `assert_contains_and_remove_publicly_created` method. If that is verified, the recipient's private balance is incremented using the `increment` helper function from the `value_note` [library](https://github.com/AztecProtocol/aztec-packages/blob/master/yarn-project/aztec-nr/value-note/src/utils.nr). +Going through the function logic, first the `secret_hash` is generated from the given secret. This ensures that only the entity possessing the secret can use it to redeem the note. Following this, a `TransparentNote` is retrieved from the set, using the provided amount and secret. The note is subsequently removed from the set, allowing it to be redeemed only once. The recipient's private balance is then increased using the `increment` helper function from the `value_note` [library](https://github.com/AztecProtocol/aztec-packages/blob/master/yarn-project/aztec-nr/value-note/src/utils.nr). The function returns `1` to indicate successful execution. diff --git a/yarn-project/acir-simulator/src/acvm/oracle/oracle.ts b/yarn-project/acir-simulator/src/acvm/oracle/oracle.ts index e587bb7db6c..ce4514e0dc7 100644 --- a/yarn-project/acir-simulator/src/acvm/oracle/oracle.ts +++ b/yarn-project/acir-simulator/src/acvm/oracle/oracle.ts @@ -80,35 +80,32 @@ export class Oracle { +offset, ); - const contractAddress = notes[0]?.contractAddress ?? Fr.ZERO; + const preimageLength = notes?.[0]?.preimage.length ?? 0; + if (!notes.every(({ preimage }) => preimageLength === preimage.length)) { + throw new Error('Preimages for a particular note type should all be the same length.'); + } - const isSome = new Fr(1); // Boolean. Indicates whether the Noir Option::is_some(); - const realNotePreimages = notes.flatMap(({ nonce, preimage }) => [nonce, isSome, ...preimage]); - const preimageLength = notes[0]?.preimage.length ?? 0; - const returnHeaderLength = 2; // is for the header values: `notes.length` and `contractAddress`. - const extraPreimageLength = 2; // is for the nonce and isSome fields. - const extendedPreimageLength = preimageLength + extraPreimageLength; - const numRealNotes = notes.length; - const numReturnNotes = Math.floor((+returnSize - returnHeaderLength) / extendedPreimageLength); - const numDummyNotes = numReturnNotes - numRealNotes; - - const dummyNotePreimage = Array(extendedPreimageLength).fill(Fr.ZERO); - const dummyNotePreimages = Array(numDummyNotes) - .fill(dummyNotePreimage) - .flatMap(note => note); - - const paddedZeros = Array( - Math.max(0, +returnSize - returnHeaderLength - realNotePreimages.length - dummyNotePreimages.length), - ).fill(Fr.ZERO); - - return [notes.length, contractAddress, ...realNotePreimages, ...dummyNotePreimages, ...paddedZeros].map(v => - toACVMField(v), - ); - } + const contractAddress = notes[0]?.contractAddress ?? Fr.ZERO; - async checkNoteHashExists([nonce]: ACVMField[], [innerNoteHash]: ACVMField[]): Promise { - const exists = await this.typedOracle.checkNoteHashExists(fromACVMField(nonce), fromACVMField(innerNoteHash)); - return toACVMField(exists); + // Values indicates whether the note is settled or transient. + const noteTypes = { + isSettled: new Fr(0), + isTransient: new Fr(1), + }; + const flattenData = notes.flatMap(({ nonce, preimage, index }) => [ + nonce, + index === undefined ? noteTypes.isTransient : noteTypes.isSettled, + ...preimage, + ]); + + const returnFieldSize = +returnSize; + const returnData = [notes.length, contractAddress, ...flattenData].map(v => toACVMField(v)); + if (returnData.length > returnFieldSize) { + throw new Error(`Return data size too big. Maximum ${returnFieldSize} fields. Got ${flattenData.length}.`); + } + + const paddedZeros = Array(returnFieldSize - returnData.length).fill(toACVMField(0)); + return returnData.concat(paddedZeros); } notifyCreatedNote([storageSlot]: ACVMField[], preimage: ACVMField[], [innerNoteHash]: ACVMField[]): ACVMField { diff --git a/yarn-project/acir-simulator/src/acvm/oracle/typed_oracle.ts b/yarn-project/acir-simulator/src/acvm/oracle/typed_oracle.ts index a972474b420..bac0a8e4611 100644 --- a/yarn-project/acir-simulator/src/acvm/oracle/typed_oracle.ts +++ b/yarn-project/acir-simulator/src/acvm/oracle/typed_oracle.ts @@ -97,10 +97,6 @@ export abstract class TypedOracle { throw new Error('Not available.'); } - checkNoteHashExists(_nonce: Fr, _innerNoteHash: Fr): Promise { - throw new Error('Not available.'); - } - notifyCreatedNote(_storageSlot: Fr, _preimage: Fr[], _innerNoteHash: Fr): void { throw new Error('Not available.'); } diff --git a/yarn-project/acir-simulator/src/client/client_execution_context.ts b/yarn-project/acir-simulator/src/client/client_execution_context.ts index b11cc97b4e6..badf3ea39a3 100644 --- a/yarn-project/acir-simulator/src/client/client_execution_context.ts +++ b/yarn-project/acir-simulator/src/client/client_execution_context.ts @@ -227,62 +227,21 @@ export class ClientExecutionContext extends ViewDataOracle { .join(', ')}`, ); - // TODO: notice, that if we don't have a note in our DB, we don't know how big the preimage needs to be, and so we don't actually know how many dummy notes to return, or big to make those dummy notes, or where to position `is_some` booleans to inform the noir program that _all_ the notes should be dummies. - // By a happy coincidence, a `0` field is interpreted as `is_none`, and since in this case (of an empty db) we'll return all zeros (paddedZeros), the noir program will treat the returned data as all dummies, but this is luck. Perhaps a preimage size should be conveyed by the get_notes Aztec.nr oracle? - const preimageLength = notes?.[0]?.preimage.length ?? 0; - if ( - !notes.every(({ preimage }) => { - return preimageLength === preimage.length; - }) - ) { - throw new Error('Preimages for a particular note type should all be the same length'); - } - const wasm = await CircuitsWasm.get(); notes.forEach(n => { if (n.index !== undefined) { const siloedNoteHash = siloCommitment(wasm, n.contractAddress, n.innerNoteHash); const uniqueSiloedNoteHash = computeUniqueCommitment(wasm, n.nonce, siloedNoteHash); - this.gotNotes.set(uniqueSiloedNoteHash.value, n.index); + // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386) + // Should always be uniqueSiloedNoteHash when publicly created notes include nonces. + const noteHashForReadRequest = n.nonce.isZero() ? siloedNoteHash : uniqueSiloedNoteHash; + this.gotNotes.set(noteHashForReadRequest.value, n.index); } }); return notes; } - /** - * Fetches a path to prove existence of a commitment in the db, given its contract side commitment (before silo). - * @param nonce - The nonce of the note. - * @param innerNoteHash - The inner note hash of the note. - * @returns 1 if (persistent or transient) note hash exists, 0 otherwise. Value is in ACVMField form. - */ - public async checkNoteHashExists(nonce: Fr, innerNoteHash: Fr): Promise { - if (nonce.isZero()) { - // If nonce is 0, we are looking for a new note created in this transaction. - const exists = this.noteCache.checkNoteExists(this.contractAddress, innerNoteHash); - if (exists) { - return true; - } - // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386) - // Currently it can also be a note created from public if nonce is 0. - // If we can't find a matching new note, keep looking for the match from the notes created in previous transactions. - } - - // If nonce is zero, SHOULD only be able to reach this point if note was publicly created - const wasm = await CircuitsWasm.get(); - let noteHashToLookUp = siloCommitment(wasm, this.contractAddress, innerNoteHash); - if (!nonce.isZero()) { - noteHashToLookUp = computeUniqueCommitment(wasm, nonce, noteHashToLookUp); - } - - const index = await this.db.getCommitmentIndex(noteHashToLookUp); - const exists = index !== undefined; - if (exists) { - this.gotNotes.set(noteHashToLookUp.value, index); - } - return exists; - } - /** * Keep track of the new note created during execution. * It can be used in subsequent calls (or transactions when chaining txs is possible). diff --git a/yarn-project/acir-simulator/src/client/execution_note_cache.ts b/yarn-project/acir-simulator/src/client/execution_note_cache.ts index 51be35a4232..9ed21b0cb80 100644 --- a/yarn-project/acir-simulator/src/client/execution_note_cache.ts +++ b/yarn-project/acir-simulator/src/client/execution_note_cache.ts @@ -53,7 +53,7 @@ export class ExecutionNoteCache { const notes = this.newNotes.get(contractAddress.toBigInt()) ?? []; const noteIndexToRemove = notes.findIndex(n => n.innerNoteHash.equals(innerNoteHash)); if (noteIndexToRemove === -1) { - throw new Error('Attemp to remove a pending note that does not exist.'); + throw new Error('Attempt to remove a pending note that does not exist.'); } notes.splice(noteIndexToRemove, 1); this.newNotes.set(contractAddress.toBigInt(), notes); diff --git a/yarn-project/acir-simulator/src/client/private_execution.test.ts b/yarn-project/acir-simulator/src/client/private_execution.test.ts index 59c3993460d..f5d8c45bb53 100644 --- a/yarn-project/acir-simulator/src/client/private_execution.test.ts +++ b/yarn-project/acir-simulator/src/client/private_execution.test.ts @@ -3,6 +3,7 @@ import { CircuitsWasm, CompleteAddress, ContractDeploymentData, + EMPTY_NULLIFIED_COMMITMENT, FieldsOf, FunctionData, HistoricBlockData, @@ -145,6 +146,13 @@ describe('Private Execution test suite', () => { }; const hash = (data: Buffer[]) => pedersenPlookupCommitInputs(circuitsWasm, data); + const hashFields = (data: Fr[]) => + Fr.fromBuffer( + pedersenPlookupCommitInputs( + circuitsWasm, + data.map(f => f.toBuffer()), + ), + ); beforeAll(async () => { circuitsWasm = await CircuitsWasm.get(); @@ -232,22 +240,11 @@ describe('Private Execution test suite', () => { const note = buildNote(60n, owner, storageSlot); // Should be the same as how we compute the values for the ValueNote in the Aztec.nr library. - const valueNoteHash = pedersenPlookupCommitInputs( - circuitsWasm, - note.preimage.map(f => f.toBuffer()), - ); - const innerNoteHash = Fr.fromBuffer( - pedersenPlookupCommitInputs(circuitsWasm, [storageSlot.toBuffer(), valueNoteHash]), - ); + const valueNoteHash = hashFields(note.preimage); + const innerNoteHash = hashFields([storageSlot, valueNoteHash]); const siloedNoteHash = siloCommitment(circuitsWasm, contractAddress, innerNoteHash); const uniqueSiloedNoteHash = computeUniqueCommitment(circuitsWasm, note.nonce, siloedNoteHash); - const innerNullifier = Fr.fromBuffer( - pedersenPlookupCommitInputs(circuitsWasm, [ - uniqueSiloedNoteHash.toBuffer(), - ownerPk.low.toBuffer(), - ownerPk.high.toBuffer(), - ]), - ); + const innerNullifier = hashFields([uniqueSiloedNoteHash, ownerPk.low, ownerPk.high]); const result = await acirSimulator.computeNoteHashAndNullifier( contractAddress, @@ -372,33 +369,6 @@ describe('Private Execution test suite', () => { expect(recipientNote.preimage[0]).toEqual(new Fr(amountToTransfer)); expect(changeNote.preimage[0]).toEqual(new Fr(balance - amountToTransfer)); }); - - it('Should be able to claim a note by providing the correct secret and nonce', async () => { - const amount = 100n; - const secret = Fr.random(); - const abi = getFunctionAbi(PrivateTokenAirdropContractAbi, 'claim'); - const storageSlot = new Fr(2n); - // choose nonzero nonce otherwise reads will be interpreted as transient (inner note hash instead of unique+siloed) - const nonce = new Fr(1n); - const customNoteHash = hash([toBufferBE(amount, 32), secret.toBuffer()]); - const innerNoteHash = Fr.fromBuffer(hash([storageSlot.toBuffer(), customNoteHash])); - oracle.getCommitmentIndex.mockResolvedValue(2n); - - const result = await runSimulator({ - abi, - args: [amount, secret, recipient, nonce], - }); - - // Check a nullifier has been inserted. - const newNullifiers = result.callStackItem.publicInputs.newNullifiers.filter(field => !field.equals(Fr.ZERO)); - expect(newNullifiers).toHaveLength(1); - - // Check the read request was inserted successfully. - const readRequests = result.callStackItem.publicInputs.readRequests.filter(field => !field.equals(Fr.ZERO)); - const siloedNoteHash = siloCommitment(circuitsWasm, contractAddress, innerNoteHash); - const uniqueSiloedNoteHash = computeUniqueCommitment(circuitsWasm, nonce, siloedNoteHash); - expect(readRequests).toEqual([uniqueSiloedNoteHash]); - }); }); describe('stateful test contract contract', () => { @@ -451,22 +421,11 @@ describe('Private Execution test suite', () => { const note = buildNote(60n, owner, storageSlot); // Should be the same as how we compute the values for the ValueNote in the Aztec.nr library. - const valueNoteHash = pedersenPlookupCommitInputs( - circuitsWasm, - note.preimage.map(f => f.toBuffer()), - ); - const innerNoteHash = Fr.fromBuffer( - pedersenPlookupCommitInputs(circuitsWasm, [storageSlot.toBuffer(), valueNoteHash]), - ); + const valueNoteHash = hashFields(note.preimage); + const innerNoteHash = hashFields([storageSlot, valueNoteHash]); const siloedNoteHash = siloCommitment(circuitsWasm, contractAddress, innerNoteHash); const uniqueSiloedNoteHash = computeUniqueCommitment(circuitsWasm, note.nonce, siloedNoteHash); - const innerNullifier = Fr.fromBuffer( - pedersenPlookupCommitInputs(circuitsWasm, [ - uniqueSiloedNoteHash.toBuffer(), - ownerPk.low.toBuffer(), - ownerPk.high.toBuffer(), - ]), - ); + const innerNullifier = hashFields([uniqueSiloedNoteHash, ownerPk.low, ownerPk.high]); const result = await acirSimulator.computeNoteHashAndNullifier( contractAddress, @@ -732,9 +691,19 @@ describe('Private Execution test suite', () => { const preimage = [toBufferBE(amount, 32), secretHash.toBuffer()]; const noteHash = Fr.fromBuffer(hash(preimage)); const storageSlot = new Fr(2); - const innerNoteHash = hash([storageSlot.toBuffer(), noteHash.toBuffer()]); - const siloedNoteHash = siloCommitment(wasm, contractAddress, Fr.fromBuffer(innerNoteHash)); - oracle.getCommitmentIndex.mockResolvedValue(0n); + const innerNoteHash = Fr.fromBuffer(hash([storageSlot.toBuffer(), noteHash.toBuffer()])); + const siloedNoteHash = siloCommitment(wasm, contractAddress, innerNoteHash); + oracle.getNotes.mockResolvedValue([ + { + contractAddress, + storageSlot, + nonce: Fr.ZERO, + preimage: preimage.map(p => Fr.fromBuffer(p)), + innerNoteHash: new Fr(EMPTY_NULLIFIED_COMMITMENT), + siloedNullifier: Fr.random(), + index: 1n, + }, + ]); const result = await runSimulator({ abi, @@ -859,9 +828,8 @@ describe('Private Execution test suite', () => { expect(gotNoteValue).toEqual(amountToTransfer); const nullifier = result.callStackItem.publicInputs.newNullifiers[0]; - expect(nullifier).toEqual( - await acirSimulator.computeInnerNullifier(contractAddress, Fr.ZERO, note.storageSlot, note.preimage), - ); + const expectedNullifier = hashFields([innerNoteHash, ownerPk.low, ownerPk.high]); + expect(nullifier).toEqual(expectedNullifier); }); it('should be able to insert, read, and nullify pending commitments in nested calls', async () => { @@ -926,11 +894,9 @@ describe('Private Execution test suite', () => { const gotNoteValue = execGetThenNullify.callStackItem.publicInputs.returnValues[0].value; expect(gotNoteValue).toEqual(amountToTransfer); - const nonce = Fr.ZERO; const nullifier = execGetThenNullify.callStackItem.publicInputs.newNullifiers[0]; - expect(nullifier).toEqual( - await acirSimulator.computeInnerNullifier(contractAddress, nonce, note.storageSlot, note.preimage), - ); + const expectedNullifier = hashFields([innerNoteHash, ownerPk.low, ownerPk.high]); + expect(nullifier).toEqual(expectedNullifier); // check that the last get_notes call return no note const afterNullifyingNoteValue = getNotesAfterNullify.callStackItem.publicInputs.returnValues[0].value; diff --git a/yarn-project/acir-simulator/src/client/view_data_oracle.ts b/yarn-project/acir-simulator/src/client/view_data_oracle.ts index 48a7466494e..679fdde388e 100644 --- a/yarn-project/acir-simulator/src/client/view_data_oracle.ts +++ b/yarn-project/acir-simulator/src/client/view_data_oracle.ts @@ -1,5 +1,4 @@ -import { CircuitsWasm, HistoricBlockData, PublicKey } from '@aztec/circuits.js'; -import { computeUniqueCommitment, siloCommitment } from '@aztec/circuits.js/abis'; +import { HistoricBlockData, PublicKey } from '@aztec/circuits.js'; import { AztecAddress } from '@aztec/foundation/aztec-address'; import { Fr } from '@aztec/foundation/fields'; import { createDebugLogger } from '@aztec/foundation/log'; @@ -100,24 +99,6 @@ export class ViewDataOracle extends TypedOracle { }); } - /** - * Fetches a path to prove existence of a commitment in the db, given its contract side commitment (before silo). - * @param nonce - The nonce of the note. - * @param innerNoteHash - The inner note hash of the note. - * @returns 1 if (persistent or transient) note hash exists, 0 otherwise. Value is in ACVMField form. - */ - public async checkNoteHashExists(nonce: Fr, innerNoteHash: Fr): Promise { - // If nonce is zero, SHOULD only be able to reach this point if note was publicly created - const wasm = await CircuitsWasm.get(); - let noteHashToLookUp = siloCommitment(wasm, this.contractAddress, innerNoteHash); - if (!nonce.isZero()) { - noteHashToLookUp = computeUniqueCommitment(wasm, nonce, noteHashToLookUp); - } - - const index = await this.db.getCommitmentIndex(noteHashToLookUp); - return index !== undefined; - } - /** * Fetches the a message from the db, given its key. * @param msgKey - A buffer representing the message key. diff --git a/yarn-project/acir-simulator/src/public/public_execution_context.ts b/yarn-project/acir-simulator/src/public/public_execution_context.ts index 04094da9211..d72fa50b1fb 100644 --- a/yarn-project/acir-simulator/src/public/public_execution_context.ts +++ b/yarn-project/acir-simulator/src/public/public_execution_context.ts @@ -1,12 +1,4 @@ -import { - CallContext, - CircuitsWasm, - FunctionData, - FunctionSelector, - GlobalVariables, - HistoricBlockData, -} from '@aztec/circuits.js'; -import { siloCommitment } from '@aztec/circuits.js/abis'; +import { CallContext, FunctionData, FunctionSelector, GlobalVariables, HistoricBlockData } from '@aztec/circuits.js'; import { AztecAddress } from '@aztec/foundation/aztec-address'; import { EthAddress } from '@aztec/foundation/eth-address'; import { Fr } from '@aztec/foundation/fields'; @@ -119,21 +111,6 @@ export class PublicExecutionContext extends TypedOracle { return { ...message, root: this.historicBlockData.l1ToL2MessagesTreeRoot }; } - /** - * Fetches a path to prove existence of a commitment in the db, given its contract side commitment (before silo). - * @param nonce - The nonce of the note. - * @param innerNoteHash - The inner note hash of the note. - * @returns 1 if (persistent or transient) note hash exists, 0 otherwise. Value is in ACVMField form. - */ - public async checkNoteHashExists(nonce: Fr, innerNoteHash: Fr): Promise { - // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386) - // Once public kernel or base rollup circuit injects nonces, this can be updated to use uniqueSiloedCommitment. - const wasm = await CircuitsWasm.get(); - const siloedNoteHash = siloCommitment(wasm, this.execution.contractAddress, innerNoteHash); - const index = await this.commitmentsDb.getCommitmentIndex(siloedNoteHash); - return index !== undefined; - } - /** * Emit an unencrypted log. * @param log - The unencrypted log to be emitted. diff --git a/yarn-project/aztec-nr/aztec/src/note/lifecycle.nr b/yarn-project/aztec-nr/aztec/src/note/lifecycle.nr index 5f4c6b2e8f9..6df1ef8ad58 100644 --- a/yarn-project/aztec-nr/aztec/src/note/lifecycle.nr +++ b/yarn-project/aztec-nr/aztec/src/note/lifecycle.nr @@ -20,7 +20,7 @@ fn create_note( ) { let contract_address = (*context).this_address(); - let header = NoteHeader { contract_address, storage_slot, nonce: 0 }; + let header = NoteHeader { contract_address, storage_slot, nonce: 0, is_transient: true }; let set_header = note_interface.set_header; set_header(note, header); let inner_note_hash = compute_inner_note_hash(note_interface, *note); @@ -40,7 +40,7 @@ fn create_note_hash_from_public( ) { let contract_address = (*context).this_address(); - let header = NoteHeader { contract_address, storage_slot, nonce: 0 }; + let header = NoteHeader { contract_address, storage_slot, nonce: 0, is_transient: true }; let set_header = note_interface.set_header; set_header(note, header); let inner_note_hash = compute_inner_note_hash(note_interface, *note); @@ -61,13 +61,12 @@ fn destroy_note( // We also need the note commitment corresponding to the "nullifier" let get_header = note_interface.get_header; let header = get_header(note); - // 0 nonce implies "transient" nullifier (must nullify a commitment in this TX). // `nullified_commitment` is used to inform the kernel which pending commitment // the nullifier corresponds to so they can be matched and both squashed/deleted. // nonzero nonce implies "persistable" nullifier (nullifies a persistent/in-tree // commitment) in which case `nullified_commitment` is not used since the kernel // just siloes and forwards the nullier to its output. - if (header.nonce == 0) { + if (header.is_transient) { // TODO(1718): Can we reuse the note commitment computed in `compute_nullifier`? nullified_commitment = compute_inner_note_hash(note_interface, note); } diff --git a/yarn-project/aztec-nr/aztec/src/note/note_getter.nr b/yarn-project/aztec-nr/aztec/src/note/note_getter.nr index 808f9389b3a..c4d86b56093 100644 --- a/yarn-project/aztec-nr/aztec/src/note/note_getter.nr +++ b/yarn-project/aztec-nr/aztec/src/note/note_getter.nr @@ -10,11 +10,8 @@ use crate::context::PrivateContext; use crate::note::{ note_getter_options::{NoteGetterOptions, Select, Sort}, note_interface::NoteInterface, - note_header::NoteHeader, note_viewer_options::NoteViewerOptions, utils::compute_note_hash_for_read_or_nullify, - utils::compute_inner_note_hash, - utils::compute_siloed_note_hash, }; use crate::oracle; use crate::types::vec::BoundedVec; @@ -32,31 +29,6 @@ fn check_note_header( assert(header.storage_slot == storage_slot); } -// Ensure a note's hash exists in the tree without retrieving the entire -// notes via the oracle. -fn ensure_note_hash_exists( - context: &mut PrivateContext, - note_interface: NoteInterface, - note: Note, - from_public: bool, -) { - let get_header = note_interface.get_header; - let header = get_header(note); - - // Check the note hash via oracle and early out if it doesn't exist. - let inner_note_hash = compute_inner_note_hash(note_interface, note); - let exists = oracle::notes::check_note_hash_exists(header.nonce, inner_note_hash); - assert(exists, "Note hash does not exist."); - - let mut note_hash_for_read_request = compute_note_hash_for_read_or_nullify(note_interface, note); - if from_public { - // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386) - // Should remove this once public kernel applies nonces. - note_hash_for_read_request = compute_siloed_note_hash(note_interface, note); - } - context.push_read_request(note_hash_for_read_request); -} - fn get_note( context: &mut PrivateContext, storage_slot: Field, diff --git a/yarn-project/aztec-nr/aztec/src/note/note_header.nr b/yarn-project/aztec-nr/aztec/src/note/note_header.nr index 8aabf7b5585..66ba4e9261d 100644 --- a/yarn-project/aztec-nr/aztec/src/note/note_header.nr +++ b/yarn-project/aztec-nr/aztec/src/note/note_header.nr @@ -2,10 +2,17 @@ struct NoteHeader { contract_address: Field, nonce: Field, storage_slot: Field, + // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386) + // Remove this and check the nonce to see whether a note is transient or not. + is_transient: bool, } impl NoteHeader { + fn new(contract_address: Field, nonce: Field, storage_slot: Field) -> Self { + NoteHeader { contract_address, nonce, storage_slot, is_transient: false } + } + fn empty() -> Self { - NoteHeader { contract_address: 0, nonce: 0, storage_slot: 0 } + NoteHeader { contract_address: 0, nonce: 0, storage_slot: 0, is_transient: false } } } \ No newline at end of file diff --git a/yarn-project/aztec-nr/aztec/src/note/utils.nr b/yarn-project/aztec-nr/aztec/src/note/utils.nr index 2c9e49efa32..8750cab7d05 100644 --- a/yarn-project/aztec-nr/aztec/src/note/utils.nr +++ b/yarn-project/aztec-nr/aztec/src/note/utils.nr @@ -49,10 +49,13 @@ fn compute_note_hash_for_read_or_nullify( let get_header = note_interface.get_header; let header = get_header(note_with_header); - if (header.nonce == 0) { - // when nonce is zero, that means we are reading a pending note (doesn't have a nonce yet), - // so we just read the inner_note_hash (kernel will silo by contract address) + // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386) + if (header.is_transient) { + // If a note is transient, we just read the inner_note_hash (kernel will silo by contract address). compute_inner_note_hash(note_interface, note_with_header) + } else if (header.nonce == 0) { + // If not transient and nonce is zero, that means we are reading a public note. + compute_siloed_note_hash(note_interface, note_with_header) } else { // When nonce is nonzero, that means we are reading a settled note (from tree) created in a // previous TX. So we need the unique_siloed_note_hash which has already been hashed with diff --git a/yarn-project/aztec-nr/aztec/src/oracle/notes.nr b/yarn-project/aztec-nr/aztec/src/oracle/notes.nr index efae0ed9e2f..4cc12f37d87 100644 --- a/yarn-project/aztec-nr/aztec/src/oracle/notes.nr +++ b/yarn-project/aztec-nr/aztec/src/oracle/notes.nr @@ -33,19 +33,6 @@ unconstrained fn notify_nullified_note( notify_nullified_note_oracle(nullifier, inner_note_hash) } -#[oracle(checkNoteHashExists)] -fn check_note_hash_exists_oracle( - _nonce: Field, - _inner_note_hash: Field, -) -> Field {} - -unconstrained fn check_note_hash_exists( - nonce: Field, - inner_note_hash: Field, -) -> bool { - check_note_hash_exists_oracle(nonce, inner_note_hash) == 1 -} - #[oracle(getNotes)] fn get_notes_oracle( _storage_slot: Field, @@ -97,17 +84,15 @@ unconstrained fn get_notes( if i as u32 < num_notes { // lengths named as per typescript. let return_header_length: Field = 2; // num_notes & contract_address. - let extra_preimage_length: Field = 2; // nonce & is_some. + let extra_preimage_length: Field = 2; // nonce & is_transient. let read_offset: Field = return_header_length + i * (N + extra_preimage_length); let nonce = fields[read_offset]; - let header = NoteHeader { contract_address, nonce, storage_slot }; - let is_some = fields[read_offset + 1] as bool; - if is_some { - let preimage = arr_copy_slice(fields, [0; N], read_offset + 2); - let mut note = deserialize(preimage); - set_header(&mut note, header); - placeholder_opt_notes[i] = Option::some(note); - } + let is_transient = fields[read_offset + 1] as bool; + let header = NoteHeader { contract_address, nonce, storage_slot, is_transient }; + let preimage = arr_copy_slice(fields, [0; N], read_offset + 2); + let mut note = deserialize(preimage); + set_header(&mut note, header); + placeholder_opt_notes[i] = Option::some(note); }; }; placeholder_opt_notes diff --git a/yarn-project/aztec-nr/aztec/src/state_vars/set.nr b/yarn-project/aztec-nr/aztec/src/state_vars/set.nr index 2aa9023aa41..162c670058f 100644 --- a/yarn-project/aztec-nr/aztec/src/state_vars/set.nr +++ b/yarn-project/aztec-nr/aztec/src/state_vars/set.nr @@ -4,7 +4,7 @@ use crate::constants_gen::{MAX_NOTES_PER_PAGE, MAX_READ_REQUESTS_PER_CALL}; use crate::context::{PrivateContext, PublicContext, Context}; use crate::note::{ lifecycle::{create_note, create_note_hash_from_public, destroy_note}, - note_getter::{ensure_note_hash_exists, get_notes, view_notes}, + note_getter::{get_notes, view_notes}, note_getter_options::NoteGetterOptions, note_header::NoteHeader, note_interface::NoteInterface, @@ -58,74 +58,15 @@ impl Set { } // docs:end:insert_from_public - // docs:start:assert_contains_and_remove - fn assert_contains_and_remove(self, note: &mut Note, nonce: Field) { - // Initialize header of note. Must be done before computing note hashes as it initializes the: - // - storage slot (used in inner note hash) - // - the contract address (used in siloed note hash) - // - and the nonce (used in the unique siloed note hash) - let context = self.context.private.unwrap(); - let set_header = self.note_interface.set_header; - let note_header = NoteHeader{ - contract_address: context.this_address(), - storage_slot: self.storage_slot, - nonce - }; - set_header(note, note_header); - - ensure_note_hash_exists( - context, - self.note_interface, - *note, - false, - ); - - destroy_note( - context, - *note, - self.note_interface, - ); + // DEPRECATED + fn assert_contains_and_remove(_self: Self, _note: &mut Note, _nonce: Field) { + assert(false, "`assert_contains_and_remove` has been deprecated. Please call PXE.addNote() to add a note to the database. Then use Set.get_notes() and Set.remove() in your contract to verify and remove a note."); } - // docs:end:assert_contains_and_remove - // docs:start:assert_contains_and_remove_publicly_created - // NOTE: this function should ONLY be used for PUBLICLY-CREATED note hashes! - // WARNING: function will be deprecated/removed eventually once public kernel applies nonces. - fn assert_contains_and_remove_publicly_created(self, note: &mut Note) { - // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386) - // Should be real nonce (once public kernel applies nonces). - let nonce = 0; - let context = self.context.private.unwrap(); - let set_header = self.note_interface.set_header; - let mut note_header = NoteHeader{ - contract_address: context.this_address(), - storage_slot: self.storage_slot, - nonce - }; - set_header(note, note_header); - - ensure_note_hash_exists( - context, - self.note_interface, - *note, - true, - ); - - // Set the nonce to nonzero so that the nullifier is treated as persistable - // (non-transient) and so the private kernel does not attempt to match it to - // a pending noteHash/commitment and squash them. - // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386): remove - // this hack once public kernel injects nonces. - note_header.nonce = 1; - set_header(note, note_header); - - destroy_note( - context, - *note, - self.note_interface, - ); + // DEPRECATED + fn assert_contains_and_remove_publicly_created(_self: Self, _note: &mut Note) { + assert(false, "`assert_contains_and_remove_publicly_created` has been deprecated. Please call PXE.addNote() to add a note to the database. Then use Set.get_notes() and Set.remove() in your contract to verify and remove a note."); } - // docs:end:assert_contains_and_remove_publicly_created // docs:start:remove fn remove(self, note: Note) { diff --git a/yarn-project/aztec.js/src/abis/ecdsa_account_contract.json b/yarn-project/aztec.js/src/abis/ecdsa_account_contract.json index 3395d700269..bc178f7093e 100644 --- a/yarn-project/aztec.js/src/abis/ecdsa_account_contract.json +++ b/yarn-project/aztec.js/src/abis/ecdsa_account_contract.json @@ -48,7 +48,7 @@ } } ], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -147,7 +147,7 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -164,7 +164,7 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { diff --git a/yarn-project/aztec.js/src/abis/schnorr_account_contract.json b/yarn-project/aztec.js/src/abis/schnorr_account_contract.json index 7580d7dbbb6..71f824b1e7a 100644 --- a/yarn-project/aztec.js/src/abis/schnorr_account_contract.json +++ b/yarn-project/aztec.js/src/abis/schnorr_account_contract.json @@ -48,7 +48,7 @@ } } ], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -135,7 +135,7 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "0000000200000800000000740000000f00000003515f3109623eb3c25aa5b16a1a79fd558bac7a7ce62c4560a8c537c77ce80dd339128d1d37b6582ee9e6df9567efb64313471dfa18f520f9ce53161b50dbf7731bc5f900000003515f322bc4cce83a486a92c92fd59bd84e0f92595baa639fc2ed86b00ffa0dfded2a092a669a3bdb7a273a015eda494457cc7ed5236f26cee330c290d45a33b9daa94800000003515f332729426c008c085a81bd34d8ef12dd31e80130339ef99d50013a89e4558eee6d0fa4ffe2ee7b7b62eb92608b2251ac31396a718f9b34978888789042b790a30100000003515f342be6b6824a913eb7a57b03cb1ee7bfb4de02f2f65fe8a4e97baa7766ddb353a82a8a25c49dc63778cd9fe96173f12a2bc77f3682f4c4448f98f1df82c75234a100000003515f351f85760d6ab567465aadc2f180af9eae3800e6958fec96aef53fd8a7b195d7c000c6267a0dd5cfc22b3fe804f53e266069c0e36f51885baec1e7e67650c62e170000000c515f41524954484d455449430d9d0f8ece2aa12012fa21e6e5c859e97bd5704e5c122064a66051294bc5e04213f61f54a0ebdf6fee4d4a6ecf693478191de0c2899bcd8e86a636c8d3eff43400000003515f43224a99d02c86336737c8dd5b746c40d2be6aead8393889a76a18d664029096e90f7fe81adcc92a74350eada9622ac453f49ebac24a066a1f83b394df54dfa0130000000c515f46495845445f42415345060e8a013ed289c2f9fd7473b04f6594b138ddb4b4cf6b901622a14088f04b8d2c83ff74fce56e3d5573b99c7b26d85d5046ce0c6559506acb7a675e7713eb3a00000007515f4c4f4749430721a91cb8da4b917e054f72147e1760cfe0ef3d45090ac0f4961d84ec1996961a25e787b26bd8b50b1a99450f77a424a83513c2b33af268cd253b0587ff50c700000003515f4d05dbd8623b8652511e1eb38d38887a69eceb082f807514f09e127237c5213b401b9325b48c6c225968002318095f89d0ef9cf629b2b7f0172e03bc39aacf6ed800000007515f52414e474504b57a3805e41df328f5ca9aefa40fad5917391543b7b65c6476e60b8f72e9ad07c92f3b3e11c8feae96dedc4b14a6226ef3201244f37cfc1ee5b96781f48d2b000000075349474d415f3125001d1954a18571eaa007144c5a567bb0d2be4def08a8be918b8c05e3b27d312c59ed41e09e144eab5de77ca89a2fd783be702a47c951d3112e3de02ce6e47c000000075349474d415f3223994e6a23618e60fa01c449a7ab88378709197e186d48d604bfb6931ffb15ad11c5ec7a0700570f80088fd5198ab5d5c227f2ad2a455a6edeec024156bb7beb000000075349474d415f3300cda5845f23468a13275d18bddae27c6bb189cf9aa95b6a03a0cb6688c7e8d829639b45cf8607c525cc400b55ebf90205f2f378626dc3406cc59b2d1b474fba000000075349474d415f342d299e7928496ea2d37f10b43afd6a80c90a33b483090d18069ffa275eedb2fc2f82121e8de43dc036d99b478b6227ceef34248939987a19011f065d8b5cef5c0000000010000000000000000100000002000000030000000400000005000000060000000700000008000000090000000a0000000b0000000c0000000d0000000e0000000f" }, { @@ -152,7 +152,7 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { diff --git a/yarn-project/aztec.js/src/index.ts b/yarn-project/aztec.js/src/index.ts index f4706d11bfa..e0d9283b9e9 100644 --- a/yarn-project/aztec.js/src/index.ts +++ b/yarn-project/aztec.js/src/index.ts @@ -16,6 +16,7 @@ export { FunctionCall, L2BlockL2Logs, NodeInfo, + NotePreimage, PackedArguments, PublicKey, GrumpkinPrivateKey, diff --git a/yarn-project/aztec.js/src/wallet/base_wallet.ts b/yarn-project/aztec.js/src/wallet/base_wallet.ts index 56cce1ea25c..a6804a1b116 100644 --- a/yarn-project/aztec.js/src/wallet/base_wallet.ts +++ b/yarn-project/aztec.js/src/wallet/base_wallet.ts @@ -1,4 +1,4 @@ -import { AztecAddress, Fr, GrumpkinPrivateKey, PartialAddress, Point } from '@aztec/circuits.js'; +import { AztecAddress, Fr, GrumpkinPrivateKey, PartialAddress } from '@aztec/circuits.js'; import { AuthWitness, ContractData, @@ -74,8 +74,15 @@ export abstract class BaseWallet implements Wallet { getPublicStorageAt(contract: AztecAddress, storageSlot: Fr): Promise { return this.pxe.getPublicStorageAt(contract, storageSlot); } - addNote(contract: AztecAddress, storageSlot: Fr, preimage: NotePreimage, nonce: Fr, account: Point): Promise { - return this.pxe.addNote(contract, storageSlot, preimage, nonce, account); + addNote( + account: AztecAddress, + contract: AztecAddress, + storageSlot: Fr, + preimage: NotePreimage, + txHash: TxHash, + nonce?: Fr, + ): Promise { + return this.pxe.addNote(account, contract, storageSlot, preimage, txHash, nonce); } getNoteNonces(contract: AztecAddress, storageSlot: Fr, preimage: NotePreimage, txHash: TxHash): Promise { return this.pxe.getNoteNonces(contract, storageSlot, preimage, txHash); diff --git a/yarn-project/boxes/private-token/src/artifacts/private_token_contract.json b/yarn-project/boxes/private-token/src/artifacts/private_token_contract.json index d2d9ae2ebb0..3bd750608be 100644 --- a/yarn-project/boxes/private-token/src/artifacts/private_token_contract.json +++ b/yarn-project/boxes/private-token/src/artifacts/private_token_contract.json @@ -48,7 +48,7 @@ } } ], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -93,7 +93,7 @@ "kind": "field" } ], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -141,22 +141,22 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" } ], "debug": { "debugSymbols": [ - "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", - "eJztmsluIjEQht+lzwjZtXjhVUY5oElGihSR0cAN8e7TAbyIVLcHDTGVKKcQ6XfzeeGrMmI/vLz+XO+eXzfbYbUfcFj92A/b3+vN23/b3frPbliZxfC0eRz/HhbDr+eXp2FlD4t3KQvRhXNyfB1LGkmKYzAxxTFEqOMPi4HUkLAaEqeGxKshCWpIohoSa/SgWD0ooAdFj2etHtFaPaa1elRr9bjW6pGt1WNb0GNb0GNb0GNb0GNb0GNb0GNb0GNb0GNb0GNb0GNb1GNb1GNb1GNb1GNb1GNb7Gnb6CHFyXC4ROlp2wZKT9s2UHratoHS07bzKNTTtg2UnrZtoPS0bQOlp20bKD1t20DRY1vSY1vSY1vSY1vSY1vWY1vWY1sWbTsmfR6EOAvkbcLxrjzdSzBg6BwF9Dl64hBVewcO0bN34BAlew1HIHeORoPzHIHxHA2R5h/q0mEKPpaHuiOyKGPdyKK0dSOLcteNLBYBS1SQnauePg5xoqznh4hSnR8yIb+QjckQZ6cdY366waLiEIQsYzI8YwEJ8Ugyob9/Jxnf32UUH+ZREDmxIPoGtzUxX76BXL25gv1cogi2XNNJipJPUYplboyiKHPNA1Nd/8fFE3itw8xbr4QUnlGwmygF33tyxz2ZKItfeU/YpCiza+xJSFuCUNRO1y7yRCH/XuRbLvJE6/HpFjnmr2aji/Uiv01yoln5zJP0dDnJifbmS03STzRkHzXJYFO9wIDUCEPOMueoM0fuia5QPfd/t6Yfx02hNLJUcwsQPguwuhbg6Uh17nnvMcXOLeQ1U2TiNEVPl6evc5t1M+7OncvNuDs3Azfj7lzfQ0ws1AyDz2WSq77kePH3nUv2rbgdLMVPZvkWwpaGwMGpz1yKm0SUuli2VfHhU7Ffih8kgNQgQIV2PgpmKR7ixhiRrTFG3LzZMWEp/2qbTdoXh7YM8oeHw+EvujKHOg==", - "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", - "eJztmttu2zAMht/F10EgkdSBeZWhF8HWAQWKdFhyF+Td5xwkax1twZgns0OvmgK/nE+HfKSdnLvXt6/708vb4djtzh12uy/n7vhjf7j+dzztf566ndl0z4dv/d/Lpvv+8vrc7exl80fKAvv4SPaveUgjSXGMhlMcI0MZf9p0pIbEqSHxakiCGpKohoTVkFijB8XqQQE9KHo8a/WI1uoxrdWjWqvHtVaPbK0e24Ie24Ie24Ie24Ie24Ie24Ie24Ie24Ie24Ie24Ie26Ie26Ie26Ie26Ie26Ie22JL23KAFCfj4nuUlratoLS0bQWlpW0rKC1tO41CLW1bQWlp2wpKS9tWUFratoLS0rYVFD22JT22JT22JT22JT22dXps6/TY1om2tUz5PTjQJFCwKRr8cPUgwYChRxQw5OidQ1TtChyiZ1fgECU7hyOSf0TZ4DRHdPiIRq5c1KfDFAMPF/U3ZFHGupFFaetGFuWuG1ksApZjPv0GcPLqzCHNzuBgvBiFrMMkUod+iPLtO16xBswh6d/fZ5QQp1EQXWJBDBVuazjf4wL5cg0FyfhEEe1wN0xSlEKKEg8741D0US4tYIq77H7xBF7rMfOWKyGFJ0znxWL4uSer7slIV/A/74kzKeqcr+xJTFuCxTLQ3EUeaXk+F3nJRR7p5z7cInN+Asqey0W+TnKkWfzIkyyamMckR9rLfzVJCkmlSPG38BVmpHFcB2akJVwH5q+bvXkw0WaYiFQJQ846l6Pe3H5017g1XIy7cfs0h5vi0IpTyS1AhMxb3D/g7ZMfGncja0yxcS8wZ4qOXJpioPenr3F5XYy7ccVcjLtxEVyMu3G9jJxYqBqGkLsZV3RW9sbduLQuxe14K57w4TmKHfo2D/dOeStOlvKTJWeL4uPuxX4rHkiA1MdBgXY/Cv0Y8TBUxohslTFiKzI1JoSt/PNuZ9K+eLTDoHB5ulx+AT7ck+w=", - "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" + "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", + "eJztml1rYjEQhv/LuRbJfOXDv7L0QrYtFIpdVu/E/75aTXKw4wmyNk5Lr2phok8m8Zn3lG6H17ffy83L22o9LLYDDYtf22H9Z7k6/LbeLP9uhoWbDU+rx/3P3Wx4fnl9Ghawm32oAmKhU+X+dZBSTayVMybO5UwhjMsfZgObIREzJN4MSTBDEs2QJDMk4OyggB0UtINix7NgR7Rgx7RgR7Vgx7VgR7Zgx7Zox7Zox7Zox7Zox7Zox7Zox7Zox7Zox7Zox7Zox7Zkx7Zkx7Zkx7Zkx7Zkx7bU07YsoaAI0zlKT9s2UHratoHS07YNlJ62nUbhnrZtoPS0bQOlp20bKD1t20DpadsGih3bsh3bsh3bsh3bsh3bih3bih3bimpbwJTKZ6BMAkWQU2n0tTJoMOhyikOqGe7Ioar2DhyqZ+/AoUr2Go7E5Zo456ZBIhXm4Kd3VwAS1Mr9ogOzamPjzKq2jTOrfjfOrA4CIKrMEkfvvl/iVWFPL1HFOr1EFyCF+sCJMN3MVATrqDYzOaVWKFteqLYoHUl0BV5Bsv98X1BCnEYhksxCFBrcABHq5Yrjw/1YHGKmiIRVa1oph1zKKZVSIVWWPmZbuoTj5mm8vtxwHHdCK57QsNfHwc+Z3PNM9NH4rc9EXC4V8Y0ziflICGva43Rlk/VZ/tPkmzZZDx9fr8kJy+SPadzkwyb1tPKlN5n4fJMX4s232mS4EMg+a5MR8rygSNwoxlIrNft69859IRWa5/7vaPp53BxrkOUxtwJReDFUOdDxSnXOvPfYYucIec0WhfOznQQ+v32dY9bNuDsnl5txdw4DN+PuPN9jyizcLMZQxqSMcsn743boPLJvxe1xrn4z618hoAYCj8ecOVcPiTmnWIHR8JHjsJ+rXyQsAQFHaKer4ObqJW6sUdkaa9TDm1wT5/p/bovL5+KpnrcPu4fd7h9RDIO1", + "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", + "eJztmstu2zAQRf9Fa8MQ58Eh/StFFkabAgECp6i9M/zv8YuU6oxECFWpSZFVEuDSOSSVMxd2js3r2/ft4eVtt282xwabzbdjs/+13V1+2h+2vw/Npl01z7sf56+nVfPz5fW52bjT6kPKITHek+fvhXMaSYsTREpxQpF+/GnVkBkSNkPizZCIGZJghiSaIXGtHRRnBwXsoNjxrLMjWmfHtM6Oap0d1zo7snV2bAt2bAt2bAt2bAt2bAt2bAt2bAt2bAt2bAt2bAt2bIt2bIt2bIt2bIt2bIt2bIs1bUssGYUJH1Fq2raAUtO2BZSati2g1LTtOArVtG0BpaZtCyg1bVtAqWnbAkpN2xZQ7NiW7NiW7NiW7NiW7NiW7diW7diWVds6gZgWCfMoUHB8jwbfJUWDgTa1OMCuw904VNUuwKF6dgEOVbJTOCLlx6Rt23GQgJlZ/PjuYgKIrkueF12YVRsbZ1a1bZxZ9btxZnUQOPHpxV1oaZw5Zo+12DHHVskyJpkydiTRXT/nVefAFJLz7/cZRcI4CiInFkQpcDsXXHY7hP4ZfgxLSBQBobOHFiVJUYoxRxlVJ/mQpNRG6B+exuvzgwT9k9DCI7bz6kD8upNF72SgGfzPd8JtijL7wp2EdCUIXamiOPGQB2rP1yHPecgDne7THXLMEz6G2D/kyyYHCuNn3mSkx00ONMx/tUmSpFKk8Ef4AjNQHZeBGeiEy8D8ddmbBhNchglIhTDkbK8k+yu3VK6Gs3FXrk9TuCl0VZz63AqEZIVLpze8/uVL5TayxBYrd4EpW2RKECz0+PRVHq+zcVeemLNxVx6Cs3FXnpchphemYhgktxnuNavrGwZSebTOxc1xrT7h3fsoruttHm5Nea1ulij1cHa94cO3Yb9WH0jIPQ56aP5eENbqw1BYo7IV1qhVZGyNyFr/F29u0714dN0iOT2dTu9c/ZDD", + "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" ], "fileMap": { "1": { - "source": "// docs:start:all\ncontract PrivateToken {\n use dep::std::option::Option;\n use dep::value_note::{\n balance_utils,\n utils::{increment, decrement},\n value_note::{VALUE_NOTE_LEN, ValueNote, ValueNoteMethods},\n };\n use dep::aztec::{\n context::{PrivateContext, PublicContext, Context},\n note::{\n note_header::NoteHeader,\n utils as note_utils,\n },\n state_vars::{map::Map, set::Set},\n };\n\n struct Storage {\n // maps an aztec address to its balance\n balances: Map>,\n }\n\n impl Storage {\n fn init(context: Context) -> pub Self {\n Storage {\n balances: Map::new(\n context,\n 1, // Storage slot\n |context, slot| {\n Set::new(context, slot, ValueNoteMethods)\n },\n ),\n }\n }\n }\n\n // docs:start:constructor\n // Constructs the contract and sets `initial_supply` which is fully owned by `owner`.\n #[aztec(private)]\n fn constructor(\n initial_supply: Field, \n owner: Field\n ) {\n let storage = Storage::init(Context::private(&mut context));\n // Insert new note to a set of user notes and emit the newly created encrypted note preimage via oracle call.\n let owner_balance = storage.balances.at(owner);\n if (initial_supply != 0) {\n increment(owner_balance, initial_supply, owner);\n }\n }\n // docs:end:constructor\n\n // docs:start:mint\n // Mints `amount` of tokens to `owner`.\n #[aztec(private)]\n fn mint(\n amount: Field, \n owner: Field\n ) {\n let storage = Storage::init(Context::private(&mut context));\n\n // Insert new note to a set of user notes and emit the newly created encrypted note preimage via oracle call.\n let owner_balance = storage.balances.at(owner);\n increment(owner_balance, amount, owner);\n }\n // docs:end:mint\n\n // Transfers `amount` of tokens from msg_sender to a `recipient`.\n #[aztec(private)]\n fn transfer(\n amount: Field, \n recipient: Field,\n ) {\n let storage = Storage::init(Context::private(&mut context));\n let sender = context.msg_sender();\n\n // Pick from the set of sender's notes to spend amount.\n let sender_balance = storage.balances.at(sender);\n decrement(sender_balance, amount, sender);\n\n // Creates new note for the recipient.\n let recipient_balance = storage.balances.at(recipient);\n increment(recipient_balance, amount, recipient);\n }\n\n // Helper function to get the balance of a user (\"unconstrained\" is a Noir alternative of Solidity's \"view\" function).\n unconstrained fn getBalance(\n owner: Field,\n ) -> Field {\n let storage = Storage::init(Context::none());\n\n // Get the set of notes owned by the user.\n let owner_balance = storage.balances.at(owner);\n\n // Return the sum of all notes in the set.\n balance_utils::get_balance(owner_balance)\n }\n\n // Computes note hash and nullifier.\n // Note 1: Needs to be defined by every contract producing logs.\n // Note 2: Having it in all the contracts gives us the ability to compute the note hash and nullifier differently for different kind of notes.\n // docs:start:compute_note_hash_and_nullifier\n unconstrained fn compute_note_hash_and_nullifier(contract_address: Field, nonce: Field, storage_slot: Field, preimage: [Field; VALUE_NOTE_LEN]) -> [Field; 4] {\n let note_header = NoteHeader { contract_address, nonce, storage_slot };\n note_utils::compute_note_hash_and_nullifier(ValueNoteMethods, note_header, preimage)\n }\n // docs:end:compute_note_hash_and_nullifier\n}\n// docs:end:all", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/noir-contracts/src/contracts/private_token_contract/src/main" + "source": "contract PrivateToken {\n use dep::std::option::Option;\n use dep::value_note::{\n balance_utils,\n utils::{increment, decrement},\n value_note::{VALUE_NOTE_LEN, ValueNote, ValueNoteMethods},\n };\n use dep::aztec::{\n context::{PrivateContext, PublicContext, Context},\n note::{\n note_header::NoteHeader,\n utils as note_utils,\n },\n state_vars::{map::Map, set::Set},\n };\n\n struct Storage {\n // maps an aztec address to its balance\n balances: Map>,\n }\n\n impl Storage {\n fn init(context: Context) -> pub Self {\n Storage {\n balances: Map::new(\n context,\n 1, // Storage slot\n |context, slot| {\n Set::new(context, slot, ValueNoteMethods)\n },\n ),\n }\n }\n }\n\n // Constructs the contract and sets `initial_supply` which is fully owned by `owner`.\n #[aztec(private)]\n fn constructor(\n initial_supply: Field, \n owner: Field\n ) {\n \n // Insert new note to a set of user notes and emit the newly created encrypted note preimage via oracle call.\n let owner_balance = storage.balances.at(owner);\n if (initial_supply != 0) {\n increment(owner_balance, initial_supply, owner);\n }\n }\n\n // Mints `amount` of tokens to `owner`.\n #[aztec(private)]\n fn mint(\n amount: Field, \n owner: Field\n ) {\n \n\n // Insert new note to a set of user notes and emit the newly created encrypted note preimage via oracle call.\n let owner_balance = storage.balances.at(owner);\n increment(owner_balance, amount, owner);\n }\n\n // Transfers `amount` of tokens from msg_sender to a `recipient`.\n #[aztec(private)]\n fn transfer(\n amount: Field, \n recipient: Field,\n ) {\n \n let sender = context.msg_sender();\n\n // Pick from the set of sender's notes to spend amount.\n let sender_balance = storage.balances.at(sender);\n decrement(sender_balance, amount, sender);\n\n // Creates new note for the recipient.\n let recipient_balance = storage.balances.at(recipient);\n increment(recipient_balance, amount, recipient);\n }\n\n // Helper function to get the balance of a user (\"unconstrained\" is a Noir alternative of Solidity's \"view\" function).\n unconstrained fn getBalance(\n owner: Field,\n ) -> Field {\n \n\n // Get the set of notes owned by the user.\n let owner_balance = storage.balances.at(owner);\n\n // Return the sum of all notes in the set.\n balance_utils::get_balance(owner_balance)\n }\n\n // Computes note hash and nullifier.\n // Note 1: Needs to be defined by every contract producing logs.\n // Note 2: Having it in all the contracts gives us the ability to compute the note hash and nullifier differently for different kind of notes.\n unconstrained fn compute_note_hash_and_nullifier(contract_address: Field, nonce: Field, storage_slot: Field, preimage: [Field; VALUE_NOTE_LEN]) -> [Field; 4] {\n let note_header = NoteHeader::new(contract_address, nonce, storage_slot);\n note_utils::compute_note_hash_and_nullifier(ValueNoteMethods, note_header, preimage)\n }\n}", + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/boxes/private-token/src/contracts/src/main" }, "4": { "source": "mod poseidon;\n\n#[foreign(sha256)]\nfn sha256(_input : [u8; N]) -> [u8; 32] {}\n\n#[foreign(blake2s)]\nfn blake2s(_input : [u8; N]) -> [u8; 32] {}\n\nfn pedersen(input : [Field; N]) -> [Field; 2] {\n pedersen_with_separator(input, 0)\n}\n\n#[foreign(pedersen)]\nfn pedersen_with_separator(_input : [Field; N], _separator : u32) -> [Field; 2] {}\n\n#[foreign(hash_to_field_128_security)]\nfn hash_to_field(_input : [Field; N]) -> Field {}\n\n#[foreign(keccak256)]\nfn keccak256(_input : [u8; N], _message_size: u32) -> [u8; 32] {}\n\n// mimc-p/p implementation\n// constants are (publicly generated) random numbers, for instance using keccak as a ROM.\n// You must use constants generated for the native field\n// Rounds number should be ~ log(p)/log(exp)\n// For 254 bit primes, exponent 7 and 91 rounds seems to be recommended\nfn mimc(x: Field, k: Field, constants: [Field; N], exp : Field) -> Field {\n //round 0\n let mut t = x + k;\n let mut h = t.pow_32(exp);\n //next rounds\n for i in 1 .. constants.len() {\n t = h + k + constants[i];\n h = t.pow_32(exp);\n };\n h + k\n}\n\nglobal MIMC_BN254_ROUNDS = 91;\n\n//mimc implementation with hardcoded parameters for BN254 curve.\nfn mimc_bn254(array: [Field; N]) -> Field {\n //mimc parameters\n let exponent = 7;\n //generated from seed \"mimc\" using keccak256 \n let constants: [Field; MIMC_BN254_ROUNDS] = [\n 0, \n 20888961410941983456478427210666206549300505294776164667214940546594746570981,\n 15265126113435022738560151911929040668591755459209400716467504685752745317193,\n 8334177627492981984476504167502758309043212251641796197711684499645635709656,\n 1374324219480165500871639364801692115397519265181803854177629327624133579404,\n 11442588683664344394633565859260176446561886575962616332903193988751292992472,\n 2558901189096558760448896669327086721003508630712968559048179091037845349145,\n 11189978595292752354820141775598510151189959177917284797737745690127318076389,\n 3262966573163560839685415914157855077211340576201936620532175028036746741754,\n 17029914891543225301403832095880481731551830725367286980611178737703889171730,\n 4614037031668406927330683909387957156531244689520944789503628527855167665518,\n 19647356996769918391113967168615123299113119185942498194367262335168397100658,\n 5040699236106090655289931820723926657076483236860546282406111821875672148900,\n 2632385916954580941368956176626336146806721642583847728103570779270161510514,\n 17691411851977575435597871505860208507285462834710151833948561098560743654671,\n 11482807709115676646560379017491661435505951727793345550942389701970904563183,\n 8360838254132998143349158726141014535383109403565779450210746881879715734773,\n 12663821244032248511491386323242575231591777785787269938928497649288048289525,\n 3067001377342968891237590775929219083706800062321980129409398033259904188058,\n 8536471869378957766675292398190944925664113548202769136103887479787957959589,\n 19825444354178182240559170937204690272111734703605805530888940813160705385792,\n 16703465144013840124940690347975638755097486902749048533167980887413919317592,\n 13061236261277650370863439564453267964462486225679643020432589226741411380501,\n 10864774797625152707517901967943775867717907803542223029967000416969007792571,\n 10035653564014594269791753415727486340557376923045841607746250017541686319774,\n 3446968588058668564420958894889124905706353937375068998436129414772610003289,\n 4653317306466493184743870159523234588955994456998076243468148492375236846006,\n 8486711143589723036499933521576871883500223198263343024003617825616410932026,\n 250710584458582618659378487568129931785810765264752039738223488321597070280,\n 2104159799604932521291371026105311735948154964200596636974609406977292675173,\n 16313562605837709339799839901240652934758303521543693857533755376563489378839,\n 6032365105133504724925793806318578936233045029919447519826248813478479197288,\n 14025118133847866722315446277964222215118620050302054655768867040006542798474,\n 7400123822125662712777833064081316757896757785777291653271747396958201309118,\n 1744432620323851751204287974553233986555641872755053103823939564833813704825,\n 8316378125659383262515151597439205374263247719876250938893842106722210729522,\n 6739722627047123650704294650168547689199576889424317598327664349670094847386,\n 21211457866117465531949733809706514799713333930924902519246949506964470524162,\n 13718112532745211817410303291774369209520657938741992779396229864894885156527,\n 5264534817993325015357427094323255342713527811596856940387954546330728068658,\n 18884137497114307927425084003812022333609937761793387700010402412840002189451,\n 5148596049900083984813839872929010525572543381981952060869301611018636120248,\n 19799686398774806587970184652860783461860993790013219899147141137827718662674,\n 19240878651604412704364448729659032944342952609050243268894572835672205984837,\n 10546185249390392695582524554167530669949955276893453512788278945742408153192,\n 5507959600969845538113649209272736011390582494851145043668969080335346810411,\n 18177751737739153338153217698774510185696788019377850245260475034576050820091,\n 19603444733183990109492724100282114612026332366576932662794133334264283907557,\n 10548274686824425401349248282213580046351514091431715597441736281987273193140,\n 1823201861560942974198127384034483127920205835821334101215923769688644479957,\n 11867589662193422187545516240823411225342068709600734253659804646934346124945,\n 18718569356736340558616379408444812528964066420519677106145092918482774343613,\n 10530777752259630125564678480897857853807637120039176813174150229243735996839,\n 20486583726592018813337145844457018474256372770211860618687961310422228379031,\n 12690713110714036569415168795200156516217175005650145422920562694422306200486,\n 17386427286863519095301372413760745749282643730629659997153085139065756667205,\n 2216432659854733047132347621569505613620980842043977268828076165669557467682,\n 6309765381643925252238633914530877025934201680691496500372265330505506717193,\n 20806323192073945401862788605803131761175139076694468214027227878952047793390,\n 4037040458505567977365391535756875199663510397600316887746139396052445718861,\n 19948974083684238245321361840704327952464170097132407924861169241740046562673,\n 845322671528508199439318170916419179535949348988022948153107378280175750024,\n 16222384601744433420585982239113457177459602187868460608565289920306145389382,\n 10232118865851112229330353999139005145127746617219324244541194256766741433339,\n 6699067738555349409504843460654299019000594109597429103342076743347235369120,\n 6220784880752427143725783746407285094967584864656399181815603544365010379208,\n 6129250029437675212264306655559561251995722990149771051304736001195288083309,\n 10773245783118750721454994239248013870822765715268323522295722350908043393604,\n 4490242021765793917495398271905043433053432245571325177153467194570741607167,\n 19596995117319480189066041930051006586888908165330319666010398892494684778526,\n 837850695495734270707668553360118467905109360511302468085569220634750561083,\n 11803922811376367215191737026157445294481406304781326649717082177394185903907,\n 10201298324909697255105265958780781450978049256931478989759448189112393506592,\n 13564695482314888817576351063608519127702411536552857463682060761575100923924,\n 9262808208636973454201420823766139682381973240743541030659775288508921362724,\n 173271062536305557219323722062711383294158572562695717740068656098441040230,\n 18120430890549410286417591505529104700901943324772175772035648111937818237369,\n 20484495168135072493552514219686101965206843697794133766912991150184337935627,\n 19155651295705203459475805213866664350848604323501251939850063308319753686505,\n 11971299749478202793661982361798418342615500543489781306376058267926437157297,\n 18285310723116790056148596536349375622245669010373674803854111592441823052978,\n 7069216248902547653615508023941692395371990416048967468982099270925308100727,\n 6465151453746412132599596984628739550147379072443683076388208843341824127379,\n 16143532858389170960690347742477978826830511669766530042104134302796355145785,\n 19362583304414853660976404410208489566967618125972377176980367224623492419647,\n 1702213613534733786921602839210290505213503664731919006932367875629005980493,\n 10781825404476535814285389902565833897646945212027592373510689209734812292327,\n 4212716923652881254737947578600828255798948993302968210248673545442808456151,\n 7594017890037021425366623750593200398174488805473151513558919864633711506220,\n 18979889247746272055963929241596362599320706910852082477600815822482192194401,\n 13602139229813231349386885113156901793661719180900395818909719758150455500533,\n ];\n\n let mut r = 0;\n for elem in array {\n let h = mimc(elem, r, constants, exponent);\n r = r + elem + h;\n }\n r\n}\n", @@ -171,92 +171,92 @@ "path": "std/grumpkin_scalar_mul" }, "34": { - "source": "use crate::constants_gen::{\n RETURN_VALUES_LENGTH,\n MAX_READ_REQUESTS_PER_CALL,\n MAX_NEW_COMMITMENTS_PER_CALL,\n MAX_NEW_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,\n MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n NUM_FIELDS_PER_SHA256,\n MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n MAX_PUBLIC_DATA_READS_PER_CALL,\n GENERATOR_INDEX__FUNCTION_ARGS,\n HISTORIC_BLOCK_DATA_LENGTH,\n CONTRACT_DEPLOYMENT_DATA_LENGTH,\n CALL_CONTEXT_LENGTH,\n PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,\n CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH,\n CONTRACT_STORAGE_READ_LENGTH,\n PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,\n GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS,\n GENERATOR_INDEX__FUNCTION_DATA,\n GENERATOR_INDEX__PUBLIC_DATA_READ,\n GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST,\n GENERATOR_INDEX__CALL_CONTEXT,\n GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS,\n GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA,\n};\n\nuse crate::oracle::debug_log;\nuse crate::types::vec::BoundedVec;\nuse crate::types::point::Point;\n\nstruct PrivateGlobalVariables {\n chain_id: Field,\n version: Field,\n}\n\nimpl PrivateGlobalVariables {\n fn serialize(self) -> [Field; 2] {\n [self.chain_id, self.version]\n }\n}\n\nstruct PublicGlobalVariables {\n chain_id: Field,\n version: Field,\n block_number: Field,\n timestamp: Field,\n}\n\nimpl PublicGlobalVariables {\n fn serialize(self) -> [Field; 4] {\n [self.chain_id, self.version, self.block_number, self.timestamp]\n }\n}\n\nstruct ContractDeploymentData {\n deployer_public_key: Point,\n constructor_vk_hash : Field,\n function_tree_root : Field,\n contract_address_salt : Field,\n portal_contract_address : Field,\n}\n\nimpl ContractDeploymentData {\n fn serialize(self) -> [Field; CONTRACT_DEPLOYMENT_DATA_LENGTH] {\n [\n self.deployer_public_key.x,\n self.deployer_public_key.y,\n self.constructor_vk_hash,\n self.function_tree_root,\n self.contract_address_salt,\n self.portal_contract_address,\n ]\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA)[0]\n }\n}\n\n// PrivateContextInputs are expected to be provided to each private function\nstruct PrivateContextInputs {\n call_context : CallContext,\n block_data: HistoricBlockData,\n\n contract_deployment_data: ContractDeploymentData,\n\n private_global_variables: PrivateGlobalVariables,\n}\n\n// PublicContextInputs are expected to be provided to each public function\nstruct PublicContextInputs {\n call_context: CallContext,\n block_data: HistoricBlockData,\n\n public_global_variables: PublicGlobalVariables,\n}\n\nstruct CallContext {\n msg_sender : Field,\n storage_contract_address : Field,\n portal_contract_address : Field,\n\n is_delegate_call : bool,\n is_static_call : bool,\n is_contract_deployment: bool,\n}\n\nimpl CallContext {\n fn serialize(self) -> [Field; CALL_CONTEXT_LENGTH] {\n [\n self.msg_sender,\n self.storage_contract_address,\n self.portal_contract_address,\n self.is_delegate_call as Field,\n self.is_static_call as Field,\n self.is_contract_deployment as Field,\n ]\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__CALL_CONTEXT)[0]\n }\n}\n\nstruct HistoricBlockData {\n private_data_tree_root : Field,\n nullifier_tree_root : Field,\n contract_tree_root : Field,\n l1_to_l2_messages_tree_root : Field,\n blocks_tree_root: Field,\n public_data_tree_root: Field,\n global_variables_hash: Field,\n}\n\nimpl HistoricBlockData {\n // NOTE: this order must match the order in `private_circuit_public_inputs.hpp`\n fn serialize(self) -> [Field; HISTORIC_BLOCK_DATA_LENGTH] {\n [\n self.private_data_tree_root,\n self.nullifier_tree_root,\n self.contract_tree_root,\n self.l1_to_l2_messages_tree_root,\n self.blocks_tree_root,\n self.public_data_tree_root,\n self.global_variables_hash,\n ]\n }\n\n fn empty() -> Self {\n Self { private_data_tree_root: 0, nullifier_tree_root: 0, contract_tree_root: 0, l1_to_l2_messages_tree_root: 0, blocks_tree_root: 0, public_data_tree_root: 0, global_variables_hash: 0 }\n }\n}\n\nstruct FunctionData {\n function_selector: Field,\n is_internal: bool,\n is_private: bool,\n is_constructor: bool,\n}\n\nimpl FunctionData {\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator([\n self.function_selector,\n self.is_internal as Field,\n self.is_private as Field,\n self.is_constructor as Field,\n ], GENERATOR_INDEX__FUNCTION_DATA)[0]\n }\n}\n\nstruct PrivateCircuitPublicInputs {\n call_context: CallContext,\n args_hash: Field,\n return_values: [Field; RETURN_VALUES_LENGTH],\n read_requests: [Field; crate::abi::MAX_READ_REQUESTS_PER_CALL],\n new_commitments: [Field; MAX_NEW_COMMITMENTS_PER_CALL],\n new_nullifiers: [Field; MAX_NEW_NULLIFIERS_PER_CALL],\n nullified_commitments: [Field; MAX_NEW_NULLIFIERS_PER_CALL],\n private_call_stack: [Field; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL],\n public_call_stack: [Field; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n new_l2_to_l1_msgs: [Field; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n // Explore introducing a new type like uint256 (similar to Point), so it's more explicit that\n // we're talking about a single number backed by two field elements.\n encrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n encrypted_log_preimages_length: Field,\n unencrypted_log_preimages_length: Field,\n block_data: HistoricBlockData,\n contract_deployment_data: ContractDeploymentData,\n chain_id: Field,\n version: Field,\n}\n\nimpl PrivateCircuitPublicInputs {\n fn hash(self) -> Field {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push(self.call_context.hash());\n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n fields.push_array(self.read_requests);\n fields.push_array(self.new_commitments);\n fields.push_array(self.new_nullifiers);\n fields.push_array(self.nullified_commitments);\n fields.push_array(self.private_call_stack);\n fields.push_array(self.public_call_stack);\n fields.push_array(self.new_l2_to_l1_msgs);\n fields.push_array(self.encrypted_logs_hash);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.encrypted_log_preimages_length);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push(self.contract_deployment_data.hash());\n fields.push(self.chain_id);\n fields.push(self.version);\n\n dep::std::hash::pedersen_with_separator(fields.storage, GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS)[0]\n }\n\n fn serialize(self) -> [Field; PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push_array(self.call_context.serialize());\n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n fields.push_array(self.read_requests);\n fields.push_array(self.new_commitments);\n fields.push_array(self.new_nullifiers);\n fields.push_array(self.private_call_stack);\n fields.push_array(self.public_call_stack);\n fields.push_array(self.new_l2_to_l1_msgs);\n fields.push_array(self.encrypted_logs_hash);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.encrypted_log_preimages_length);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push_array(self.contract_deployment_data.serialize());\n fields.push(self.chain_id);\n fields.push(self.version);\n fields.storage\n }\n}\n\nstruct ContractStorageRead {\n storage_slot: Field,\n value: Field,\n}\n\nimpl ContractStorageRead {\n fn serialize(self) -> [Field; CONTRACT_STORAGE_READ_LENGTH] {\n [self.storage_slot, self.value]\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_READ)[0]\n }\n\n fn empty() -> Self {\n Self { storage_slot: 0, value: 0 }\n }\n}\n\nstruct ContractStorageUpdateRequest {\n storage_slot: Field,\n old_value: Field,\n new_value: Field,\n}\n\nimpl ContractStorageUpdateRequest {\n fn serialize(self) -> [Field; CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH] {\n [self.storage_slot, self.old_value, self.new_value]\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST)[0]\n }\n\n fn empty() -> Self {\n Self { storage_slot: 0, old_value: 0, new_value: 0 }\n }\n}\n\n\nstruct PublicCircuitPublicInputs {\n call_context: CallContext,\n args_hash: Field,\n return_values: [Field; RETURN_VALUES_LENGTH],\n contract_storage_update_requests: [ContractStorageUpdateRequest; MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL],\n contract_storage_read: [ContractStorageRead; MAX_PUBLIC_DATA_READS_PER_CALL],\n public_call_stack: [Field; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n new_commitments: [Field; MAX_NEW_COMMITMENTS_PER_CALL],\n new_nullifiers: [Field; crate::abi::MAX_NEW_NULLIFIERS_PER_CALL],\n new_l2_to_l1_msgs: [Field; crate::abi::MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n unencrypted_log_preimages_length: Field,\n block_data: HistoricBlockData,\n prover_address: Field,\n\n // TODO: include globals in here and check them elsewhere\n // https://github.com/AztecProtocol/aztec-packages/issues/1567\n}\n\nimpl PublicCircuitPublicInputs {\n \n fn hash(self) -> Field {\n let mut inputs: BoundedVec = BoundedVec::new(0);\n inputs.push(self.call_context.hash());\n inputs.push(self.args_hash);\n inputs.push_array(self.return_values);\n for i in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL {\n inputs.push(self.contract_storage_update_requests[i].hash());\n }\n for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL {\n inputs.push(self.contract_storage_read[i].hash());\n }\n inputs.push_array(self.public_call_stack);\n inputs.push_array(self.new_commitments);\n inputs.push_array(self.new_nullifiers);\n inputs.push_array(self.new_l2_to_l1_msgs);\n\n // We do not include block_data since it's not in the cpp hash\n\n inputs.push_array(self.unencrypted_logs_hash);\n inputs.push(self.unencrypted_log_preimages_length);\n inputs.push_array(self.block_data.serialize()); // see https://github.com/AztecProtocol/aztec-packages/issues/1473\n inputs.push(self.prover_address);\n\n dep::std::hash::pedersen_with_separator(inputs.storage, GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS)[0]\n }\n\n fn serialize(self) -> [Field; PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push_array(self.call_context.serialize()); \n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n for i in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL {\n fields.push_array(self.contract_storage_update_requests[i].serialize());\n }\n for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL {\n fields.push_array(self.contract_storage_read[i].serialize());\n }\n fields.push_array(self.public_call_stack);\n fields.push_array(self.new_commitments);\n fields.push_array(self.new_nullifiers);\n fields.push_array(self.new_l2_to_l1_msgs);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push(self.prover_address);\n fields.storage\n }\n}\n\nstruct Hasher {\n fields: [Field],\n}\n\nimpl Hasher {\n fn new()-> Self {\n Self { fields: [] }\n }\n\n fn add(&mut self, field: Field) {\n self.fields = self.fields.push_back(field);\n }\n\n fn add_multiple(&mut self, fields: [Field; N]) {\n for i in 0..N {\n self.fields = self.fields.push_back(fields[i]);\n }\n }\n\n fn hash(self) -> Field {\n hash_args(self.fields)\n }\n}\n\nglobal ARGS_HASH_CHUNK_LENGTH: u32 = 32;\nglobal ARGS_HASH_CHUNK_COUNT: u32 = 16;\n\nfn hash_args(args: [Field; N]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n let mut chunks_hashes = [0; ARGS_HASH_CHUNK_COUNT];\n for i in 0..ARGS_HASH_CHUNK_COUNT {\n let mut chunk_hash = 0;\n let start_chunk_index = i * ARGS_HASH_CHUNK_LENGTH;\n if start_chunk_index < (args.len() as u32) {\n let mut chunk_args = [0; ARGS_HASH_CHUNK_LENGTH];\n for j in 0..ARGS_HASH_CHUNK_LENGTH {\n let item_index = i * ARGS_HASH_CHUNK_LENGTH + j;\n if item_index < (args.len() as u32) {\n chunk_args[j] = args[item_index];\n }\n }\n chunk_hash = dep::std::hash::pedersen_with_separator(chunk_args, GENERATOR_INDEX__FUNCTION_ARGS)[0];\n }\n chunks_hashes[i] = chunk_hash;\n }\n dep::std::hash::pedersen_with_separator(chunks_hashes, GENERATOR_INDEX__FUNCTION_ARGS)[0]\n }\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/abi" + "source": "use crate::constants_gen::{\n RETURN_VALUES_LENGTH,\n MAX_READ_REQUESTS_PER_CALL,\n MAX_NEW_COMMITMENTS_PER_CALL,\n MAX_NEW_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,\n MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n NUM_FIELDS_PER_SHA256,\n MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n MAX_PUBLIC_DATA_READS_PER_CALL,\n GENERATOR_INDEX__FUNCTION_ARGS,\n HISTORIC_BLOCK_DATA_LENGTH,\n CONTRACT_DEPLOYMENT_DATA_LENGTH,\n CALL_CONTEXT_LENGTH,\n PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,\n CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH,\n CONTRACT_STORAGE_READ_LENGTH,\n PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,\n GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS,\n GENERATOR_INDEX__FUNCTION_DATA,\n GENERATOR_INDEX__PUBLIC_DATA_READ,\n GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST,\n GENERATOR_INDEX__CALL_CONTEXT,\n GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS,\n GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA,\n};\n\nuse crate::oracle::debug_log;\nuse crate::types::vec::BoundedVec;\nuse crate::types::point::Point;\n\n\n// docs:start:private-global-variables\nstruct PrivateGlobalVariables {\n chain_id: Field,\n version: Field,\n}\n// docs:end:private-global-variables\n\nimpl PrivateGlobalVariables {\n fn serialize(self) -> [Field; 2] {\n [self.chain_id, self.version]\n }\n}\n\n// docs:start:public-global-variables\nstruct PublicGlobalVariables {\n chain_id: Field,\n version: Field,\n block_number: Field,\n timestamp: Field,\n}\n// docs:end:public-global-variables\n\nimpl PublicGlobalVariables {\n fn serialize(self) -> [Field; 4] {\n [self.chain_id, self.version, self.block_number, self.timestamp]\n }\n}\n\n// docs:start:contract-deployment-data\nstruct ContractDeploymentData {\n deployer_public_key: Point,\n constructor_vk_hash : Field,\n function_tree_root : Field,\n contract_address_salt : Field,\n portal_contract_address : Field,\n}\n// docs:end:contract-deployment-data\n\nimpl ContractDeploymentData {\n fn serialize(self) -> [Field; CONTRACT_DEPLOYMENT_DATA_LENGTH] {\n [\n self.deployer_public_key.x,\n self.deployer_public_key.y,\n self.constructor_vk_hash,\n self.function_tree_root,\n self.contract_address_salt,\n self.portal_contract_address,\n ]\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA)[0]\n }\n}\n\n// PrivateContextInputs are expected to be provided to each private function\n// docs:start:private-context-inputs\nstruct PrivateContextInputs {\n call_context : CallContext,\n block_data: HistoricBlockData,\n contract_deployment_data: ContractDeploymentData,\n private_global_variables: PrivateGlobalVariables,\n}\n// docs:end:private-context-inputs\n\n// PublicContextInputs are expected to be provided to each public function\n// docs:start:public-context-inputs\nstruct PublicContextInputs {\n call_context: CallContext,\n block_data: HistoricBlockData,\n\n public_global_variables: PublicGlobalVariables,\n}\n// docs:end:public-context-inputs\n\n// docs:start:call-context\nstruct CallContext {\n msg_sender : Field,\n storage_contract_address : Field,\n portal_contract_address : Field,\n\n is_delegate_call : bool,\n is_static_call : bool,\n is_contract_deployment: bool,\n}\n// docs:end:call-context\n\nimpl CallContext {\n fn serialize(self) -> [Field; CALL_CONTEXT_LENGTH] {\n [\n self.msg_sender,\n self.storage_contract_address,\n self.portal_contract_address,\n self.is_delegate_call as Field,\n self.is_static_call as Field,\n self.is_contract_deployment as Field,\n ]\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__CALL_CONTEXT)[0]\n }\n}\n\n// docs:start:historic-block-data\nstruct HistoricBlockData {\n private_data_tree_root : Field,\n nullifier_tree_root : Field,\n contract_tree_root : Field,\n l1_to_l2_messages_tree_root : Field,\n blocks_tree_root: Field,\n public_data_tree_root: Field,\n global_variables_hash: Field,\n}\n// docs:end:historic-block-data\n\nimpl HistoricBlockData {\n // NOTE: this order must match the order in `private_circuit_public_inputs.hpp`\n fn serialize(self) -> [Field; HISTORIC_BLOCK_DATA_LENGTH] {\n [\n self.private_data_tree_root,\n self.nullifier_tree_root,\n self.contract_tree_root,\n self.l1_to_l2_messages_tree_root,\n self.blocks_tree_root,\n self.public_data_tree_root,\n self.global_variables_hash,\n ]\n }\n\n fn empty() -> Self {\n Self { private_data_tree_root: 0, nullifier_tree_root: 0, contract_tree_root: 0, l1_to_l2_messages_tree_root: 0, blocks_tree_root: 0, public_data_tree_root: 0, global_variables_hash: 0 }\n }\n}\n\nstruct FunctionData {\n function_selector: Field,\n is_internal: bool,\n is_private: bool,\n is_constructor: bool,\n}\n\nimpl FunctionData {\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator([\n self.function_selector,\n self.is_internal as Field,\n self.is_private as Field,\n self.is_constructor as Field,\n ], GENERATOR_INDEX__FUNCTION_DATA)[0]\n }\n}\n\nstruct PrivateCircuitPublicInputs {\n call_context: CallContext,\n args_hash: Field,\n return_values: [Field; RETURN_VALUES_LENGTH],\n read_requests: [Field; crate::abi::MAX_READ_REQUESTS_PER_CALL],\n new_commitments: [Field; MAX_NEW_COMMITMENTS_PER_CALL],\n new_nullifiers: [Field; MAX_NEW_NULLIFIERS_PER_CALL],\n nullified_commitments: [Field; MAX_NEW_NULLIFIERS_PER_CALL],\n private_call_stack: [Field; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL],\n public_call_stack: [Field; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n new_l2_to_l1_msgs: [Field; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n // Explore introducing a new type like uint256 (similar to Point), so it's more explicit that\n // we're talking about a single number backed by two field elements.\n encrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n encrypted_log_preimages_length: Field,\n unencrypted_log_preimages_length: Field,\n block_data: HistoricBlockData,\n contract_deployment_data: ContractDeploymentData,\n chain_id: Field,\n version: Field,\n}\n\nimpl PrivateCircuitPublicInputs {\n fn hash(self) -> Field {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push(self.call_context.hash());\n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n fields.push_array(self.read_requests);\n fields.push_array(self.new_commitments);\n fields.push_array(self.new_nullifiers);\n fields.push_array(self.nullified_commitments);\n fields.push_array(self.private_call_stack);\n fields.push_array(self.public_call_stack);\n fields.push_array(self.new_l2_to_l1_msgs);\n fields.push_array(self.encrypted_logs_hash);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.encrypted_log_preimages_length);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push(self.contract_deployment_data.hash());\n fields.push(self.chain_id);\n fields.push(self.version);\n\n dep::std::hash::pedersen_with_separator(fields.storage, GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS)[0]\n }\n\n fn serialize(self) -> [Field; PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push_array(self.call_context.serialize());\n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n fields.push_array(self.read_requests);\n fields.push_array(self.new_commitments);\n fields.push_array(self.new_nullifiers);\n fields.push_array(self.private_call_stack);\n fields.push_array(self.public_call_stack);\n fields.push_array(self.new_l2_to_l1_msgs);\n fields.push_array(self.encrypted_logs_hash);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.encrypted_log_preimages_length);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push_array(self.contract_deployment_data.serialize());\n fields.push(self.chain_id);\n fields.push(self.version);\n fields.storage\n }\n}\n\nstruct ContractStorageRead {\n storage_slot: Field,\n value: Field,\n}\n\nimpl ContractStorageRead {\n fn serialize(self) -> [Field; CONTRACT_STORAGE_READ_LENGTH] {\n [self.storage_slot, self.value]\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_READ)[0]\n }\n\n fn empty() -> Self {\n Self { storage_slot: 0, value: 0 }\n }\n}\n\nstruct ContractStorageUpdateRequest {\n storage_slot: Field,\n old_value: Field,\n new_value: Field,\n}\n\nimpl ContractStorageUpdateRequest {\n fn serialize(self) -> [Field; CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH] {\n [self.storage_slot, self.old_value, self.new_value]\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST)[0]\n }\n\n fn empty() -> Self {\n Self { storage_slot: 0, old_value: 0, new_value: 0 }\n }\n}\n\n\nstruct PublicCircuitPublicInputs {\n call_context: CallContext,\n args_hash: Field,\n return_values: [Field; RETURN_VALUES_LENGTH],\n contract_storage_update_requests: [ContractStorageUpdateRequest; MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL],\n contract_storage_read: [ContractStorageRead; MAX_PUBLIC_DATA_READS_PER_CALL],\n public_call_stack: [Field; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n new_commitments: [Field; MAX_NEW_COMMITMENTS_PER_CALL],\n new_nullifiers: [Field; crate::abi::MAX_NEW_NULLIFIERS_PER_CALL],\n new_l2_to_l1_msgs: [Field; crate::abi::MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n unencrypted_log_preimages_length: Field,\n block_data: HistoricBlockData,\n prover_address: Field,\n\n // TODO: include globals in here and check them elsewhere\n // https://github.com/AztecProtocol/aztec-packages/issues/1567\n}\n\nimpl PublicCircuitPublicInputs {\n \n fn hash(self) -> Field {\n let mut inputs: BoundedVec = BoundedVec::new(0);\n inputs.push(self.call_context.hash());\n inputs.push(self.args_hash);\n inputs.push_array(self.return_values);\n for i in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL {\n inputs.push(self.contract_storage_update_requests[i].hash());\n }\n for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL {\n inputs.push(self.contract_storage_read[i].hash());\n }\n inputs.push_array(self.public_call_stack);\n inputs.push_array(self.new_commitments);\n inputs.push_array(self.new_nullifiers);\n inputs.push_array(self.new_l2_to_l1_msgs);\n\n // We do not include block_data since it's not in the cpp hash\n\n inputs.push_array(self.unencrypted_logs_hash);\n inputs.push(self.unencrypted_log_preimages_length);\n inputs.push_array(self.block_data.serialize()); // see https://github.com/AztecProtocol/aztec-packages/issues/1473\n inputs.push(self.prover_address);\n\n dep::std::hash::pedersen_with_separator(inputs.storage, GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS)[0]\n }\n\n fn serialize(self) -> [Field; PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push_array(self.call_context.serialize()); \n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n for i in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL {\n fields.push_array(self.contract_storage_update_requests[i].serialize());\n }\n for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL {\n fields.push_array(self.contract_storage_read[i].serialize());\n }\n fields.push_array(self.public_call_stack);\n fields.push_array(self.new_commitments);\n fields.push_array(self.new_nullifiers);\n fields.push_array(self.new_l2_to_l1_msgs);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push(self.prover_address);\n fields.storage\n }\n}\n\nstruct Hasher {\n fields: [Field],\n}\n\nimpl Hasher {\n fn new()-> Self {\n Self { fields: [] }\n }\n\n fn add(&mut self, field: Field) {\n self.fields = self.fields.push_back(field);\n }\n\n fn add_multiple(&mut self, fields: [Field; N]) {\n for i in 0..N {\n self.fields = self.fields.push_back(fields[i]);\n }\n }\n\n fn hash(self) -> Field {\n hash_args(self.fields)\n }\n}\n\nglobal ARGS_HASH_CHUNK_LENGTH: u32 = 32;\nglobal ARGS_HASH_CHUNK_COUNT: u32 = 16;\n\nfn hash_args(args: [Field; N]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n let mut chunks_hashes = [0; ARGS_HASH_CHUNK_COUNT];\n for i in 0..ARGS_HASH_CHUNK_COUNT {\n let mut chunk_hash = 0;\n let start_chunk_index = i * ARGS_HASH_CHUNK_LENGTH;\n if start_chunk_index < (args.len() as u32) {\n let mut chunk_args = [0; ARGS_HASH_CHUNK_LENGTH];\n for j in 0..ARGS_HASH_CHUNK_LENGTH {\n let item_index = i * ARGS_HASH_CHUNK_LENGTH + j;\n if item_index < (args.len() as u32) {\n chunk_args[j] = args[item_index];\n }\n }\n chunk_hash = dep::std::hash::pedersen_with_separator(chunk_args, GENERATOR_INDEX__FUNCTION_ARGS)[0];\n }\n chunks_hashes[i] = chunk_hash;\n }\n dep::std::hash::pedersen_with_separator(chunks_hashes, GENERATOR_INDEX__FUNCTION_ARGS)[0]\n }\n}\n", + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/aztec/src/abi" }, "36": { "source": "use dep::std::hash;\nuse crate::constants_gen::GENERATOR_INDEX__CONTRACT_ADDRESS;\n\nfn compute_address(pub_key_x: Field, pub_key_y: Field, partial_address: Field) -> Field {\n hash::pedersen_with_separator([pub_key_x, pub_key_y, partial_address], GENERATOR_INDEX__CONTRACT_ADDRESS)[0]\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/address" + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/aztec/src/address" }, "39": { - "source": "use crate::constants_gen::{\n EMPTY_NULLIFIED_COMMITMENT,\n MAX_NEW_COMMITMENTS_PER_CALL,\n MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n MAX_NEW_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,\n MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n MAX_PUBLIC_DATA_READS_PER_CALL,\n MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n MAX_READ_REQUESTS_PER_CALL,\n NUM_FIELDS_PER_SHA256,\n RETURN_VALUES_LENGTH,\n};\n\nuse crate::abi;\n\nuse crate::abi::{\n hash_args,\n CallContext,\n ContractDeploymentData,\n HistoricBlockData,\n FunctionData,\n PrivateCircuitPublicInputs,\n PublicCircuitPublicInputs,\n};\n\n// TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n// use dep::std::collections::vec::Vec;\n\n// l1 to l2 messaging\nuse crate::messaging::process_l1_to_l2_message;\nuse crate::private_call_stack_item::PrivateCallStackItem;\nuse crate::public_call_stack_item::PublicCallStackItem;\n\nuse crate::types::{\n vec::BoundedVec,\n point::Point,\n};\n\nuse crate::utils::arr_copy_slice;\n\nuse crate::oracle::{\n arguments,\n call_private_function::call_private_function_internal,\n public_call::call_public_function_internal,\n enqueue_public_function_call::enqueue_public_function_call_internal,\n context::get_portal_address,\n};\n\nuse dep::std::option::Option;\n\n// When finished, one can call .finish() to convert back to the abi\nstruct PrivateContext {\n inputs: abi::PrivateContextInputs,\n\n args_hash : Field,\n return_values : BoundedVec,\n\n read_requests: BoundedVec,\n\n new_commitments: BoundedVec,\n new_nullifiers: BoundedVec,\n nullified_commitments: BoundedVec,\n\n private_call_stack : BoundedVec,\n public_call_stack : BoundedVec,\n new_l2_to_l1_msgs : BoundedVec,\n\n block_data: HistoricBlockData,\n\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n // encrypted_logs_preimages: Vec,\n // unencrypted_logs_preimages: Vec,\n}\n\nimpl PrivateContext {\n fn new(inputs: abi::PrivateContextInputs, args_hash: Field) -> PrivateContext {\n PrivateContext {\n inputs: inputs,\n\n args_hash: args_hash,\n return_values: BoundedVec::new(0),\n\n read_requests: BoundedVec::new(0),\n\n new_commitments: BoundedVec::new(0),\n new_nullifiers: BoundedVec::new(0),\n nullified_commitments: BoundedVec::new(0),\n\n block_data: inputs.block_data,\n\n private_call_stack: BoundedVec::new(0),\n public_call_stack: BoundedVec::new(0),\n new_l2_to_l1_msgs: BoundedVec::new(0),\n\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n // encrypted_logs_preimages: Vec::new(),\n // unencrypted_logs_preimages: Vec::new(),\n }\n }\n\n fn msg_sender(self) -> Field {\n self.inputs.call_context.msg_sender\n }\n\n fn this_address(self) -> Field {\n self.inputs.call_context.storage_contract_address\n }\n\n fn this_portal_address(self) -> Field {\n self.inputs.call_context.portal_contract_address\n }\n\n fn chain_id(self) -> Field {\n self.inputs.private_global_variables.chain_id\n }\n\n fn version(self) -> Field {\n self.inputs.private_global_variables.version\n }\n\n fn finish(self) -> abi::PrivateCircuitPublicInputs {\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n let encrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n let unencrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n let encrypted_log_preimages_length = 0;\n let unencrypted_log_preimages_length = 0;\n\n let priv_circuit_pub_inputs = abi::PrivateCircuitPublicInputs {\n call_context: self.inputs.call_context,\n args_hash: self.args_hash,\n return_values: self.return_values.storage,\n read_requests: self.read_requests.storage,\n new_commitments: self.new_commitments.storage,\n new_nullifiers: self.new_nullifiers.storage,\n nullified_commitments: self.nullified_commitments.storage,\n private_call_stack: self.private_call_stack.storage,\n public_call_stack: self.public_call_stack.storage,\n new_l2_to_l1_msgs: self.new_l2_to_l1_msgs.storage,\n encrypted_logs_hash: encrypted_logs_hash,\n unencrypted_logs_hash: unencrypted_logs_hash,\n encrypted_log_preimages_length: encrypted_log_preimages_length,\n unencrypted_log_preimages_length: unencrypted_log_preimages_length,\n block_data: self.block_data,\n contract_deployment_data: self.inputs.contract_deployment_data,\n chain_id: self.inputs.private_global_variables.chain_id,\n version: self.inputs.private_global_variables.version,\n };\n priv_circuit_pub_inputs\n }\n\n fn push_read_request(&mut self, read_request: Field) {\n self.read_requests.push(read_request);\n }\n\n fn push_new_note_hash(&mut self, note_hash: Field) {\n self.new_commitments.push(note_hash);\n }\n\n fn push_new_nullifier(&mut self, nullifier: Field, nullified_commitment: Field) {\n self.new_nullifiers.push(nullifier);\n self.nullified_commitments.push(nullified_commitment);\n }\n\n // docs:start:context_message_portal\n fn message_portal(&mut self, content: Field) \n // docs:end:context_message_portal\n {\n self.new_l2_to_l1_msgs.push(content);\n }\n\n // PrivateContextInputs must be temporarily passed in to prevent too many unknowns\n // Note this returns self to get around an issue where mutable structs do not maintain mutations unless reassigned\n // docs:start:context_consume_l1_to_l2_message\n fn consume_l1_to_l2_message(\n &mut self,\n msg_key: Field,\n content: Field,\n secret: Field\n ) \n // docs:end:context_consume_l1_to_l2_message\n {\n let nullifier = process_l1_to_l2_message(self.block_data.l1_to_l2_messages_tree_root, self.this_address(), msg_key, content, secret);\n\n // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n self.push_new_nullifier(nullifier, EMPTY_NULLIFIED_COMMITMENT)\n }\n\n fn accumulate_encrypted_logs(&mut self, log: [Field; N]) {\n let _void1 = self.inputs;\n let _void2 = log;\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n }\n\n fn accumulate_unencrypted_logs(&mut self, log: T) {\n let _void1 = self.inputs;\n let _void2 = log;\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n }\n\n fn call_private_function(\n &mut self,\n contract_address: Field, \n function_selector: Field, \n args: [Field; ARGS_COUNT]\n ) -> [Field; RETURN_VALUES_LENGTH] {\n let args_hash = hash_args(args);\n assert(args_hash == arguments::pack_arguments(args));\n self.call_private_function_with_packed_args(contract_address, function_selector, args_hash)\n }\n\n fn call_private_function_no_args(\n &mut self,\n contract_address: Field, \n function_selector: Field, \n ) -> [Field; RETURN_VALUES_LENGTH] {\n self.call_private_function_with_packed_args(contract_address, function_selector, 0)\n }\n\n fn call_private_function_with_packed_args(\n &mut self,\n contract_address: Field,\n function_selector: Field,\n args_hash: Field\n ) -> [Field; RETURN_VALUES_LENGTH] {\n let fields = call_private_function_internal(\n contract_address, \n function_selector, \n args_hash\n );\n let item = PrivateCallStackItem {\n contract_address: fields[0],\n function_data: FunctionData {\n function_selector: fields[1],\n is_internal: fields[2] as bool,\n is_private: fields[3] as bool,\n is_constructor: fields[4] as bool,\n },\n public_inputs: PrivateCircuitPublicInputs {\n call_context: CallContext {\n msg_sender : fields[5],\n storage_contract_address : fields[6],\n portal_contract_address : fields[7],\n \n is_delegate_call : fields[8] as bool,\n is_static_call : fields[9] as bool,\n is_contract_deployment: fields[10] as bool,\n },\n // TODO handle the offsets as a variable incremented during extraction?\n args_hash: fields[11],\n return_values: arr_copy_slice(fields, [0; RETURN_VALUES_LENGTH], 12),\n read_requests: arr_copy_slice(fields, [0; MAX_READ_REQUESTS_PER_CALL], 16),\n new_commitments: arr_copy_slice(fields, [0; MAX_NEW_COMMITMENTS_PER_CALL], 48),\n new_nullifiers: arr_copy_slice(fields, [0; MAX_NEW_NULLIFIERS_PER_CALL], 64),\n nullified_commitments: arr_copy_slice(fields, [0; MAX_NEW_NULLIFIERS_PER_CALL], 80),\n private_call_stack: arr_copy_slice(fields, [0; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL], 96),\n public_call_stack: arr_copy_slice(fields, [0; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL], 100),\n new_l2_to_l1_msgs: arr_copy_slice(fields, [0; MAX_NEW_L2_TO_L1_MSGS_PER_CALL], 104),\n encrypted_logs_hash: arr_copy_slice(fields, [0; NUM_FIELDS_PER_SHA256], 106),\n unencrypted_logs_hash: arr_copy_slice(fields, [0; NUM_FIELDS_PER_SHA256], 108),\n encrypted_log_preimages_length: fields[110],\n unencrypted_log_preimages_length: fields[111],\n block_data: HistoricBlockData {\n // Must match order in `private_circuit_public_inputs.hpp`\n private_data_tree_root : fields[112],\n nullifier_tree_root : fields[113],\n contract_tree_root : fields[114],\n l1_to_l2_messages_tree_root : fields[115],\n blocks_tree_root : fields[116],\n public_data_tree_root: fields[117],\n global_variables_hash: fields[118],\n },\n contract_deployment_data: ContractDeploymentData {\n deployer_public_key: Point::new(fields[119], fields[120]),\n constructor_vk_hash : fields[121],\n function_tree_root : fields[122],\n contract_address_salt : fields[123],\n portal_contract_address : fields[124],\n },\n chain_id: fields[125],\n version: fields[126],\n },\n is_execution_request: fields[127] as bool,\n };\n assert(contract_address == item.contract_address);\n assert(function_selector == item.function_data.function_selector);\n\n assert(args_hash == item.public_inputs.args_hash);\n\n assert(item.is_execution_request == false);\n\n // Assert that the call context of the enqueued call generated by the oracle matches our request.\n // We are issuing a regular call which is not delegate, static, or deployment. We also constrain\n // the msg_sender in the nested call to be equal to our address, and the execution context address\n // for the nested call to be equal to the address we actually called.\n assert(item.public_inputs.call_context.is_delegate_call == false);\n assert(item.public_inputs.call_context.is_static_call == false);\n assert(item.public_inputs.call_context.is_contract_deployment == false);\n assert(item.public_inputs.call_context.msg_sender == self.inputs.call_context.storage_contract_address);\n assert(item.public_inputs.call_context.storage_contract_address == contract_address);\n\n self.private_call_stack.push(item.hash());\n\n item.public_inputs.return_values\n }\n\n fn call_public_function(\n &mut self,\n contract_address: Field, \n function_selector: Field, \n args: [Field; ARGS_COUNT]\n ) {\n let args_hash = hash_args(args);\n assert(args_hash == arguments::pack_arguments(args));\n self.call_public_function_with_packed_args(contract_address, function_selector, args_hash)\n }\n\n fn call_public_function_no_args(\n &mut self,\n contract_address: Field, \n function_selector: Field,\n ) {\n self.call_public_function_with_packed_args(contract_address, function_selector, 0)\n }\n\n fn call_public_function_with_packed_args(\n &mut self,\n contract_address: Field,\n function_selector: Field,\n args_hash: Field\n ) {\n let fields = enqueue_public_function_call_internal(\n contract_address, \n function_selector, \n args_hash\n );\n let item = PublicCallStackItem {\n contract_address: fields[0],\n function_data: FunctionData {\n function_selector: fields[1],\n is_internal: fields[2] as bool,\n is_private: fields[3] as bool,\n is_constructor: fields[4] as bool,\n },\n public_inputs: PublicCircuitPublicInputs {\n call_context: CallContext {\n msg_sender : fields[5],\n storage_contract_address : fields[6],\n portal_contract_address : fields[7],\n \n is_delegate_call : fields[8] as bool,\n is_static_call : fields[9] as bool,\n is_contract_deployment: fields[10] as bool,\n },\n args_hash: fields[11],\n return_values: [0; RETURN_VALUES_LENGTH],\n contract_storage_update_requests: [ContractStorageUpdateRequest::empty(); MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL],\n contract_storage_read: [ContractStorageRead::empty(); MAX_PUBLIC_DATA_READS_PER_CALL],\n public_call_stack: [0; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n new_commitments: [0; MAX_NEW_COMMITMENTS_PER_CALL],\n new_nullifiers: [0; MAX_NEW_NULLIFIERS_PER_CALL],\n new_l2_to_l1_msgs:[0; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n unencrypted_logs_hash:[0; NUM_FIELDS_PER_SHA256],\n unencrypted_log_preimages_length: 0,\n block_data: HistoricBlockData::empty(),\n prover_address: 0,\n },\n is_execution_request: true,\n };\n\n assert(contract_address == item.contract_address);\n assert(function_selector == item.function_data.function_selector);\n \n assert(args_hash == item.public_inputs.args_hash);\n\n // Assert that the call context of the enqueued call generated by the oracle matches our request.\n // We are issuing a regular call which is not delegate, static, or deployment. We also constrain\n // the msg_sender in the nested call to be equal to our address, and the execution context address\n // for the nested call to be equal to the address we actually called.\n assert(item.public_inputs.call_context.is_delegate_call == false);\n assert(item.public_inputs.call_context.is_static_call == false);\n assert(item.public_inputs.call_context.is_contract_deployment == false);\n assert(item.public_inputs.call_context.msg_sender == self.inputs.call_context.storage_contract_address);\n assert(item.public_inputs.call_context.storage_contract_address == contract_address);\n\n self.public_call_stack.push(item.hash());\n }\n}\n\nuse crate::abi::{\n ContractStorageRead,\n ContractStorageUpdateRequest\n};\n\nstruct PublicContext {\n inputs: abi::PublicContextInputs,\n\n args_hash : Field,\n return_values : BoundedVec,\n\n contract_storage_update_requests: BoundedVec,\n contract_storage_read: BoundedVec,\n public_call_stack: BoundedVec,\n\n new_commitments: BoundedVec,\n new_nullifiers: BoundedVec,\n\n new_l2_to_l1_msgs: BoundedVec,\n\n unencrypted_logs_hash: BoundedVec,\n unencrypted_logs_preimages_length: Field,\n\n block_data: HistoricBlockData,\n prover_address: Field,\n}\n\nimpl PublicContext {\n fn new(inputs: abi::PublicContextInputs, args_hash: Field) -> PublicContext {\n let empty_storage_read = ContractStorageRead::empty();\n let empty_storage_update = ContractStorageUpdateRequest::empty();\n PublicContext {\n inputs: inputs,\n\n args_hash: args_hash,\n return_values: BoundedVec::new(0),\n\n contract_storage_update_requests: BoundedVec::new(empty_storage_update),\n contract_storage_read: BoundedVec::new(empty_storage_read),\n public_call_stack: BoundedVec::new(0),\n\n new_commitments: BoundedVec::new(0),\n new_nullifiers: BoundedVec::new(0),\n\n new_l2_to_l1_msgs: BoundedVec::new(0),\n\n \n unencrypted_logs_hash: BoundedVec::new(0),\n unencrypted_logs_preimages_length: 0,\n\n block_data: inputs.block_data,\n prover_address: 0,\n\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n // encrypted_logs_preimages: Vec::new(),\n // unencrypted_logs_preimages: Vec::new(),\n }\n }\n\n fn msg_sender(self) -> Field {\n self.inputs.call_context.msg_sender\n }\n\n fn this_address(self) -> Field {\n self.inputs.call_context.storage_contract_address\n }\n\n fn this_portal_address(self) -> Field {\n self.inputs.call_context.portal_contract_address\n }\n\n fn chain_id(self) -> Field {\n self.inputs.public_global_variables.chain_id\n }\n\n fn version(self) -> Field {\n self.inputs.public_global_variables.version\n }\n\n fn block_number(self) -> Field {\n self.inputs.public_global_variables.block_number\n }\n\n fn timestamp(self) -> Field {\n self.inputs.public_global_variables.timestamp\n }\n\n fn finish(self) -> abi::PublicCircuitPublicInputs {\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n let unencrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n let unencrypted_log_preimages_length = 0;\n\n\n // Compute the public call stack hashes\n let pub_circuit_pub_inputs = abi::PublicCircuitPublicInputs {\n call_context: self.inputs.call_context, // Done\n args_hash: self.args_hash, // Done\n contract_storage_update_requests: self.contract_storage_update_requests.storage,\n contract_storage_read: self.contract_storage_read.storage,\n return_values: self.return_values.storage,\n new_commitments: self.new_commitments.storage,\n new_nullifiers: self.new_nullifiers.storage,\n public_call_stack: self.public_call_stack.storage,\n new_l2_to_l1_msgs: self.new_l2_to_l1_msgs.storage,\n unencrypted_logs_hash: unencrypted_logs_hash,\n unencrypted_log_preimages_length: unencrypted_log_preimages_length,\n block_data: self.inputs.block_data,\n prover_address: self.prover_address,\n };\n pub_circuit_pub_inputs\n }\n\n fn push_new_note_hash(&mut self, note_hash: Field) {\n self.new_commitments.push(note_hash);\n }\n\n fn push_new_nullifier(&mut self, nullifier: Field, _nullified_commitment: Field) {\n self.new_nullifiers.push(nullifier);\n }\n\n fn message_portal(&mut self, content: Field) {\n self.new_l2_to_l1_msgs.push(content);\n }\n\n // PrivateContextInputs must be temporarily passed in to prevent too many unknowns\n // Note this returns self to get around an issue where mutable structs do not maintain mutations unless reassigned\n fn consume_l1_to_l2_message(&mut self, msg_key: Field, content: Field, secret: Field) {\n let this = (*self).this_address();\n let nullifier = process_l1_to_l2_message(self.block_data.l1_to_l2_messages_tree_root, this, msg_key, content, secret);\n\n // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n self.push_new_nullifier(nullifier, EMPTY_NULLIFIED_COMMITMENT)\n }\n\n fn accumulate_encrypted_logs(&mut self, log: [Field; N]) {\n let _void1 = self;\n let _void2 = log;\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n }\n\n fn accumulate_unencrypted_logs(&mut self, log: T) {\n let _void1 = self;\n let _void2 = log;\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n }\n\n fn call_public_function(\n _self: Self,\n contract_address: Field, \n function_selector: Field,\n args: [Field; ARGS_COUNT],\n ) -> [Field; RETURN_VALUES_LENGTH] {\n let args_hash = abi::hash_args(args);\n assert(args_hash == arguments::pack_arguments(args));\n call_public_function_internal(\n contract_address, \n function_selector, \n args_hash,\n )\n }\n\n fn call_public_function_no_args(\n _self: Self,\n contract_address: Field, \n function_selector: Field,\n ) -> [Field; RETURN_VALUES_LENGTH] {\n call_public_function_internal(\n contract_address, \n function_selector, \n 0,\n )\n }\n\n}\n\nstruct Context {\n private: Option<&mut PrivateContext>,\n public: Option<&mut PublicContext>,\n}\n\nimpl Context {\n fn private(context: &mut PrivateContext) -> Context {\n Context {\n private: Option::some(context),\n public: Option::none()\n }\n }\n\n fn public(context: &mut PublicContext) -> Context {\n Context {\n public: Option::some(context),\n private: Option::none()\n }\n }\n\n fn none() -> Context {\n Context {\n public: Option::none(),\n private: Option::none()\n }\n }\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/context" + "source": "use crate::constants_gen::{\n EMPTY_NULLIFIED_COMMITMENT,\n MAX_NEW_COMMITMENTS_PER_CALL,\n MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n MAX_NEW_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,\n MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n MAX_PUBLIC_DATA_READS_PER_CALL,\n MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n MAX_READ_REQUESTS_PER_CALL,\n NUM_FIELDS_PER_SHA256,\n RETURN_VALUES_LENGTH,\n};\n\nuse crate::abi;\n\nuse crate::abi::{\n hash_args,\n CallContext,\n ContractDeploymentData,\n HistoricBlockData,\n FunctionData,\n PrivateCircuitPublicInputs,\n PublicCircuitPublicInputs,\n};\n\n// TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n// use dep::std::collections::vec::Vec;\n\n// l1 to l2 messaging\nuse crate::messaging::process_l1_to_l2_message;\nuse crate::private_call_stack_item::PrivateCallStackItem;\nuse crate::public_call_stack_item::PublicCallStackItem;\n\nuse crate::types::{\n vec::BoundedVec,\n point::Point,\n};\n\nuse crate::utils::arr_copy_slice;\n\nuse crate::oracle::{\n arguments,\n call_private_function::call_private_function_internal,\n public_call::call_public_function_internal,\n enqueue_public_function_call::enqueue_public_function_call_internal,\n context::get_portal_address,\n};\n\nuse dep::std::option::Option;\n\n// When finished, one can call .finish() to convert back to the abi\nstruct PrivateContext {\n // docs:start:private-context\n inputs: abi::PrivateContextInputs,\n\n args_hash : Field,\n return_values : BoundedVec,\n\n read_requests: BoundedVec,\n\n new_commitments: BoundedVec,\n new_nullifiers: BoundedVec,\n nullified_commitments: BoundedVec,\n\n private_call_stack : BoundedVec,\n public_call_stack : BoundedVec,\n new_l2_to_l1_msgs : BoundedVec,\n // docs:end:private-context\n\n block_data: HistoricBlockData,\n\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n // encrypted_logs_preimages: Vec,\n // unencrypted_logs_preimages: Vec,\n}\n\nimpl PrivateContext {\n fn new(inputs: abi::PrivateContextInputs, args_hash: Field) -> PrivateContext {\n PrivateContext {\n inputs: inputs,\n\n args_hash: args_hash,\n return_values: BoundedVec::new(0),\n\n read_requests: BoundedVec::new(0),\n\n new_commitments: BoundedVec::new(0),\n new_nullifiers: BoundedVec::new(0),\n nullified_commitments: BoundedVec::new(0),\n\n block_data: inputs.block_data,\n\n private_call_stack: BoundedVec::new(0),\n public_call_stack: BoundedVec::new(0),\n new_l2_to_l1_msgs: BoundedVec::new(0),\n\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n // encrypted_logs_preimages: Vec::new(),\n // unencrypted_logs_preimages: Vec::new(),\n }\n }\n\n fn msg_sender(self) -> Field {\n self.inputs.call_context.msg_sender\n }\n\n fn this_address(self) -> Field {\n self.inputs.call_context.storage_contract_address\n }\n\n fn this_portal_address(self) -> Field {\n self.inputs.call_context.portal_contract_address\n }\n\n fn chain_id(self) -> Field {\n self.inputs.private_global_variables.chain_id\n }\n\n fn version(self) -> Field {\n self.inputs.private_global_variables.version\n }\n\n fn finish(self) -> abi::PrivateCircuitPublicInputs {\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n let encrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n let unencrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n let encrypted_log_preimages_length = 0;\n let unencrypted_log_preimages_length = 0;\n\n let priv_circuit_pub_inputs = abi::PrivateCircuitPublicInputs {\n call_context: self.inputs.call_context,\n args_hash: self.args_hash,\n return_values: self.return_values.storage,\n read_requests: self.read_requests.storage,\n new_commitments: self.new_commitments.storage,\n new_nullifiers: self.new_nullifiers.storage,\n nullified_commitments: self.nullified_commitments.storage,\n private_call_stack: self.private_call_stack.storage,\n public_call_stack: self.public_call_stack.storage,\n new_l2_to_l1_msgs: self.new_l2_to_l1_msgs.storage,\n encrypted_logs_hash: encrypted_logs_hash,\n unencrypted_logs_hash: unencrypted_logs_hash,\n encrypted_log_preimages_length: encrypted_log_preimages_length,\n unencrypted_log_preimages_length: unencrypted_log_preimages_length,\n block_data: self.block_data,\n contract_deployment_data: self.inputs.contract_deployment_data,\n chain_id: self.inputs.private_global_variables.chain_id,\n version: self.inputs.private_global_variables.version,\n };\n priv_circuit_pub_inputs\n }\n\n fn push_read_request(&mut self, read_request: Field) {\n self.read_requests.push(read_request);\n }\n\n fn push_new_note_hash(&mut self, note_hash: Field) {\n self.new_commitments.push(note_hash);\n }\n\n // We never push a zero nullified_commitment as zero is used to indicate the end\n // of a field array in private kernel. This routine transparently replaces a\n // zero value into the special placeholder: EMPTY_NULLIFIED_COMMITMENT.\n fn push_new_nullifier(&mut self, nullifier: Field, nullified_commitment: Field) {\n self.new_nullifiers.push(nullifier);\n let mut non_zero_nullified = nullified_commitment;\n if (non_zero_nullified == 0) {\n non_zero_nullified = EMPTY_NULLIFIED_COMMITMENT;\n }\n self.nullified_commitments.push(non_zero_nullified);\n }\n\n // docs:start:context_message_portal\n fn message_portal(&mut self, content: Field) \n // docs:end:context_message_portal\n {\n self.new_l2_to_l1_msgs.push(content);\n }\n\n // PrivateContextInputs must be temporarily passed in to prevent too many unknowns\n // Note this returns self to get around an issue where mutable structs do not maintain mutations unless reassigned\n // docs:start:context_consume_l1_to_l2_message\n // docs:start:consume_l1_to_l2_message\n fn consume_l1_to_l2_message(\n &mut self,\n msg_key: Field,\n content: Field,\n secret: Field\n ) \n // docs:end:context_consume_l1_to_l2_message\n {\n let nullifier = process_l1_to_l2_message(self.block_data.l1_to_l2_messages_tree_root, self.this_address(), msg_key, content, secret);\n\n // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n self.push_new_nullifier(nullifier, EMPTY_NULLIFIED_COMMITMENT)\n }\n // docs:end:consume_l1_to_l2_message\n\n fn accumulate_encrypted_logs(&mut self, log: [Field; N]) {\n let _void1 = self.inputs;\n let _void2 = log;\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n }\n\n fn accumulate_unencrypted_logs(&mut self, log: T) {\n let _void1 = self.inputs;\n let _void2 = log;\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n }\n\n fn call_private_function(\n &mut self,\n contract_address: Field, \n function_selector: Field, \n args: [Field; ARGS_COUNT]\n ) -> [Field; RETURN_VALUES_LENGTH] {\n let args_hash = hash_args(args);\n assert(args_hash == arguments::pack_arguments(args));\n self.call_private_function_with_packed_args(contract_address, function_selector, args_hash)\n }\n\n fn call_private_function_no_args(\n &mut self,\n contract_address: Field, \n function_selector: Field, \n ) -> [Field; RETURN_VALUES_LENGTH] {\n self.call_private_function_with_packed_args(contract_address, function_selector, 0)\n }\n\n fn call_private_function_with_packed_args(\n &mut self,\n contract_address: Field,\n function_selector: Field,\n args_hash: Field\n ) -> [Field; RETURN_VALUES_LENGTH] {\n let fields = call_private_function_internal(\n contract_address, \n function_selector, \n args_hash\n );\n let item = PrivateCallStackItem {\n contract_address: fields[0],\n function_data: FunctionData {\n function_selector: fields[1],\n is_internal: fields[2] as bool,\n is_private: fields[3] as bool,\n is_constructor: fields[4] as bool,\n },\n public_inputs: PrivateCircuitPublicInputs {\n call_context: CallContext {\n msg_sender : fields[5],\n storage_contract_address : fields[6],\n portal_contract_address : fields[7],\n \n is_delegate_call : fields[8] as bool,\n is_static_call : fields[9] as bool,\n is_contract_deployment: fields[10] as bool,\n },\n // TODO handle the offsets as a variable incremented during extraction?\n args_hash: fields[11],\n return_values: arr_copy_slice(fields, [0; RETURN_VALUES_LENGTH], 12),\n read_requests: arr_copy_slice(fields, [0; MAX_READ_REQUESTS_PER_CALL], 16),\n new_commitments: arr_copy_slice(fields, [0; MAX_NEW_COMMITMENTS_PER_CALL], 48),\n new_nullifiers: arr_copy_slice(fields, [0; MAX_NEW_NULLIFIERS_PER_CALL], 64),\n nullified_commitments: arr_copy_slice(fields, [0; MAX_NEW_NULLIFIERS_PER_CALL], 80),\n private_call_stack: arr_copy_slice(fields, [0; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL], 96),\n public_call_stack: arr_copy_slice(fields, [0; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL], 100),\n new_l2_to_l1_msgs: arr_copy_slice(fields, [0; MAX_NEW_L2_TO_L1_MSGS_PER_CALL], 104),\n encrypted_logs_hash: arr_copy_slice(fields, [0; NUM_FIELDS_PER_SHA256], 106),\n unencrypted_logs_hash: arr_copy_slice(fields, [0; NUM_FIELDS_PER_SHA256], 108),\n encrypted_log_preimages_length: fields[110],\n unencrypted_log_preimages_length: fields[111],\n block_data: HistoricBlockData {\n // Must match order in `private_circuit_public_inputs.hpp`\n private_data_tree_root : fields[112],\n nullifier_tree_root : fields[113],\n contract_tree_root : fields[114],\n l1_to_l2_messages_tree_root : fields[115],\n blocks_tree_root : fields[116],\n public_data_tree_root: fields[117],\n global_variables_hash: fields[118],\n },\n contract_deployment_data: ContractDeploymentData {\n deployer_public_key: Point::new(fields[119], fields[120]),\n constructor_vk_hash : fields[121],\n function_tree_root : fields[122],\n contract_address_salt : fields[123],\n portal_contract_address : fields[124],\n },\n chain_id: fields[125],\n version: fields[126],\n },\n is_execution_request: fields[127] as bool,\n };\n assert(contract_address == item.contract_address);\n assert(function_selector == item.function_data.function_selector);\n\n assert(args_hash == item.public_inputs.args_hash);\n\n assert(item.is_execution_request == false);\n\n // Assert that the call context of the enqueued call generated by the oracle matches our request.\n // We are issuing a regular call which is not delegate, static, or deployment. We also constrain\n // the msg_sender in the nested call to be equal to our address, and the execution context address\n // for the nested call to be equal to the address we actually called.\n assert(item.public_inputs.call_context.is_delegate_call == false);\n assert(item.public_inputs.call_context.is_static_call == false);\n assert(item.public_inputs.call_context.is_contract_deployment == false);\n assert(item.public_inputs.call_context.msg_sender == self.inputs.call_context.storage_contract_address);\n assert(item.public_inputs.call_context.storage_contract_address == contract_address);\n\n self.private_call_stack.push(item.hash());\n\n item.public_inputs.return_values\n }\n\n fn call_public_function(\n &mut self,\n contract_address: Field, \n function_selector: Field, \n args: [Field; ARGS_COUNT]\n ) {\n let args_hash = hash_args(args);\n assert(args_hash == arguments::pack_arguments(args));\n self.call_public_function_with_packed_args(contract_address, function_selector, args_hash)\n }\n\n fn call_public_function_no_args(\n &mut self,\n contract_address: Field, \n function_selector: Field,\n ) {\n self.call_public_function_with_packed_args(contract_address, function_selector, 0)\n }\n\n fn call_public_function_with_packed_args(\n &mut self,\n contract_address: Field,\n function_selector: Field,\n args_hash: Field\n ) {\n let fields = enqueue_public_function_call_internal(\n contract_address, \n function_selector, \n args_hash\n );\n let item = PublicCallStackItem {\n contract_address: fields[0],\n function_data: FunctionData {\n function_selector: fields[1],\n is_internal: fields[2] as bool,\n is_private: fields[3] as bool,\n is_constructor: fields[4] as bool,\n },\n public_inputs: PublicCircuitPublicInputs {\n call_context: CallContext {\n msg_sender : fields[5],\n storage_contract_address : fields[6],\n portal_contract_address : fields[7],\n \n is_delegate_call : fields[8] as bool,\n is_static_call : fields[9] as bool,\n is_contract_deployment: fields[10] as bool,\n },\n args_hash: fields[11],\n return_values: [0; RETURN_VALUES_LENGTH],\n contract_storage_update_requests: [ContractStorageUpdateRequest::empty(); MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL],\n contract_storage_read: [ContractStorageRead::empty(); MAX_PUBLIC_DATA_READS_PER_CALL],\n public_call_stack: [0; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n new_commitments: [0; MAX_NEW_COMMITMENTS_PER_CALL],\n new_nullifiers: [0; MAX_NEW_NULLIFIERS_PER_CALL],\n new_l2_to_l1_msgs:[0; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n unencrypted_logs_hash:[0; NUM_FIELDS_PER_SHA256],\n unencrypted_log_preimages_length: 0,\n block_data: HistoricBlockData::empty(),\n prover_address: 0,\n },\n is_execution_request: true,\n };\n\n assert(contract_address == item.contract_address);\n assert(function_selector == item.function_data.function_selector);\n \n assert(args_hash == item.public_inputs.args_hash);\n\n // Assert that the call context of the enqueued call generated by the oracle matches our request.\n // We are issuing a regular call which is not delegate, static, or deployment. We also constrain\n // the msg_sender in the nested call to be equal to our address, and the execution context address\n // for the nested call to be equal to the address we actually called.\n assert(item.public_inputs.call_context.is_delegate_call == false);\n assert(item.public_inputs.call_context.is_static_call == false);\n assert(item.public_inputs.call_context.is_contract_deployment == false);\n assert(item.public_inputs.call_context.msg_sender == self.inputs.call_context.storage_contract_address);\n assert(item.public_inputs.call_context.storage_contract_address == contract_address);\n\n self.public_call_stack.push(item.hash());\n }\n}\n\nuse crate::abi::{\n ContractStorageRead,\n ContractStorageUpdateRequest\n};\n\nstruct PublicContext {\n inputs: abi::PublicContextInputs,\n\n args_hash : Field,\n return_values : BoundedVec,\n\n contract_storage_update_requests: BoundedVec,\n contract_storage_read: BoundedVec,\n public_call_stack: BoundedVec,\n\n new_commitments: BoundedVec,\n new_nullifiers: BoundedVec,\n\n new_l2_to_l1_msgs: BoundedVec,\n\n unencrypted_logs_hash: BoundedVec,\n unencrypted_logs_preimages_length: Field,\n\n block_data: HistoricBlockData,\n prover_address: Field,\n}\n\nimpl PublicContext {\n fn new(inputs: abi::PublicContextInputs, args_hash: Field) -> PublicContext {\n let empty_storage_read = ContractStorageRead::empty();\n let empty_storage_update = ContractStorageUpdateRequest::empty();\n PublicContext {\n inputs: inputs,\n\n args_hash: args_hash,\n return_values: BoundedVec::new(0),\n\n contract_storage_update_requests: BoundedVec::new(empty_storage_update),\n contract_storage_read: BoundedVec::new(empty_storage_read),\n public_call_stack: BoundedVec::new(0),\n\n new_commitments: BoundedVec::new(0),\n new_nullifiers: BoundedVec::new(0),\n\n new_l2_to_l1_msgs: BoundedVec::new(0),\n\n \n unencrypted_logs_hash: BoundedVec::new(0),\n unencrypted_logs_preimages_length: 0,\n\n block_data: inputs.block_data,\n prover_address: 0,\n\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n // encrypted_logs_preimages: Vec::new(),\n // unencrypted_logs_preimages: Vec::new(),\n }\n }\n\n fn msg_sender(self) -> Field {\n self.inputs.call_context.msg_sender\n }\n\n fn this_address(self) -> Field {\n self.inputs.call_context.storage_contract_address\n }\n\n fn this_portal_address(self) -> Field {\n self.inputs.call_context.portal_contract_address\n }\n\n fn chain_id(self) -> Field {\n self.inputs.public_global_variables.chain_id\n }\n\n fn version(self) -> Field {\n self.inputs.public_global_variables.version\n }\n\n fn block_number(self) -> Field {\n self.inputs.public_global_variables.block_number\n }\n\n fn timestamp(self) -> Field {\n self.inputs.public_global_variables.timestamp\n }\n\n fn finish(self) -> abi::PublicCircuitPublicInputs {\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n let unencrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n let unencrypted_log_preimages_length = 0;\n\n\n // Compute the public call stack hashes\n let pub_circuit_pub_inputs = abi::PublicCircuitPublicInputs {\n call_context: self.inputs.call_context, // Done\n args_hash: self.args_hash, // Done\n contract_storage_update_requests: self.contract_storage_update_requests.storage,\n contract_storage_read: self.contract_storage_read.storage,\n return_values: self.return_values.storage,\n new_commitments: self.new_commitments.storage,\n new_nullifiers: self.new_nullifiers.storage,\n public_call_stack: self.public_call_stack.storage,\n new_l2_to_l1_msgs: self.new_l2_to_l1_msgs.storage,\n unencrypted_logs_hash: unencrypted_logs_hash,\n unencrypted_log_preimages_length: unencrypted_log_preimages_length,\n block_data: self.inputs.block_data,\n prover_address: self.prover_address,\n };\n pub_circuit_pub_inputs\n }\n\n fn push_new_note_hash(&mut self, note_hash: Field) {\n self.new_commitments.push(note_hash);\n }\n\n fn push_new_nullifier(&mut self, nullifier: Field, _nullified_commitment: Field) {\n self.new_nullifiers.push(nullifier);\n }\n\n fn message_portal(&mut self, content: Field) {\n self.new_l2_to_l1_msgs.push(content);\n }\n\n // PrivateContextInputs must be temporarily passed in to prevent too many unknowns\n // Note this returns self to get around an issue where mutable structs do not maintain mutations unless reassigned\n fn consume_l1_to_l2_message(&mut self, msg_key: Field, content: Field, secret: Field) {\n let this = (*self).this_address();\n let nullifier = process_l1_to_l2_message(self.block_data.l1_to_l2_messages_tree_root, this, msg_key, content, secret);\n\n // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n self.push_new_nullifier(nullifier, EMPTY_NULLIFIED_COMMITMENT)\n }\n\n fn accumulate_encrypted_logs(&mut self, log: [Field; N]) {\n let _void1 = self;\n let _void2 = log;\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n }\n\n fn accumulate_unencrypted_logs(&mut self, log: T) {\n let _void1 = self;\n let _void2 = log;\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n }\n\n fn call_public_function(\n _self: Self,\n contract_address: Field, \n function_selector: Field,\n args: [Field; ARGS_COUNT],\n ) -> [Field; RETURN_VALUES_LENGTH] {\n let args_hash = abi::hash_args(args);\n assert(args_hash == arguments::pack_arguments(args));\n call_public_function_internal(\n contract_address, \n function_selector, \n args_hash,\n )\n }\n\n fn call_public_function_no_args(\n _self: Self,\n contract_address: Field, \n function_selector: Field,\n ) -> [Field; RETURN_VALUES_LENGTH] {\n call_public_function_internal(\n contract_address, \n function_selector, \n 0,\n )\n }\n\n}\n\nstruct Context {\n private: Option<&mut PrivateContext>,\n public: Option<&mut PublicContext>,\n}\n\nimpl Context {\n fn private(context: &mut PrivateContext) -> Context {\n Context {\n private: Option::some(context),\n public: Option::none()\n }\n }\n\n fn public(context: &mut PublicContext) -> Context {\n Context {\n public: Option::some(context),\n private: Option::none()\n }\n }\n\n fn none() -> Context {\n Context {\n public: Option::none(),\n private: Option::none()\n }\n }\n}", + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/aztec/src/context" }, "41": { "source": "use crate::context::PrivateContext;\nuse crate::oracle;\nuse crate::types::point::Point;\n\nfn emit_encrypted_log(\n context: &mut PrivateContext,\n contract_address: Field,\n storage_slot: Field,\n encryption_pub_key: Point,\n log: [Field; N],\n) {\n let _ = oracle::logs::emit_encrypted_log(contract_address, storage_slot, encryption_pub_key, log);\n context.accumulate_encrypted_logs(log);\n}\n\nfn emit_unencrypted_log(\n context: &mut PrivateContext,\n log: T,\n) {\n let _ = oracle::logs::emit_unencrypted_log(log);\n context.accumulate_unencrypted_logs(log);\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/log" + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/aztec/src/log" }, "46": { - "source": "use dep::std::option::Option;\nuse crate::abi::PublicContextInputs;\nuse crate::context::{\n PrivateContext,\n PublicContext,\n};\nuse crate::note::{\n note_header::NoteHeader,\n note_interface::NoteInterface,\n utils::compute_inner_note_hash,\n};\nuse crate::oracle::notes::{notify_created_note, notify_nullified_note};\nuse crate::constants_gen::EMPTY_NULLIFIED_COMMITMENT;\n\nfn create_note(\n context: &mut PrivateContext,\n storage_slot: Field,\n note: &mut Note,\n note_interface: NoteInterface,\n) {\n let contract_address = (*context).this_address();\n\n let header = NoteHeader { contract_address, storage_slot, nonce: 0 };\n let set_header = note_interface.set_header;\n set_header(note, header);\n let inner_note_hash = compute_inner_note_hash(note_interface, *note);\n\n let serialise = note_interface.serialise;\n let preimage = serialise(*note);\n assert(notify_created_note(storage_slot, preimage, inner_note_hash) == 0);\n\n context.push_new_note_hash(inner_note_hash);\n}\n\nfn create_note_hash_from_public(\n context: &mut PublicContext,\n storage_slot: Field,\n note: &mut Note,\n note_interface: NoteInterface,\n) {\n let contract_address = (*context).this_address();\n\n let header = NoteHeader { contract_address, storage_slot, nonce: 0 };\n let set_header = note_interface.set_header;\n set_header(note, header);\n let inner_note_hash = compute_inner_note_hash(note_interface, *note);\n\n context.push_new_note_hash(inner_note_hash);\n}\n\nfn destroy_note(\n context: &mut PrivateContext,\n note: Note,\n note_interface: NoteInterface,\n) {\n let mut nullifier = 0;\n let mut nullified_commitment: Field = EMPTY_NULLIFIED_COMMITMENT;\n let compute_nullifier = note_interface.compute_nullifier;\n nullifier = compute_nullifier(note);\n\n // We also need the note commitment corresponding to the \"nullifier\"\n let get_header = note_interface.get_header;\n let header = get_header(note);\n // 0 nonce implies \"transient\" nullifier (must nullify a commitment in this TX).\n // `nullified_commitment` is used to inform the kernel which pending commitment\n // the nullifier corresponds to so they can be matched and both squashed/deleted.\n // nonzero nonce implies \"persistable\" nullifier (nullifies a persistent/in-tree\n // commitment) in which case `nullified_commitment` is not used since the kernel\n // just siloes and forwards the nullier to its output.\n if (header.nonce == 0) {\n // TODO(1718): Can we reuse the note commitment computed in `compute_nullifier`?\n nullified_commitment = compute_inner_note_hash(note_interface, note);\n }\n assert(notify_nullified_note(nullifier, nullified_commitment) == 0);\n\n context.push_new_nullifier(nullifier, nullified_commitment)\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/note/lifecycle" + "source": "use dep::std::option::Option;\nuse crate::abi::PublicContextInputs;\nuse crate::context::{\n PrivateContext,\n PublicContext,\n};\nuse crate::note::{\n note_header::NoteHeader,\n note_interface::NoteInterface,\n utils::compute_inner_note_hash,\n};\nuse crate::oracle::notes::{notify_created_note, notify_nullified_note};\nuse crate::constants_gen::EMPTY_NULLIFIED_COMMITMENT;\n\nfn create_note(\n context: &mut PrivateContext,\n storage_slot: Field,\n note: &mut Note,\n note_interface: NoteInterface,\n) {\n let contract_address = (*context).this_address();\n\n let header = NoteHeader { contract_address, storage_slot, nonce: 0, is_transient: true };\n let set_header = note_interface.set_header;\n set_header(note, header);\n let inner_note_hash = compute_inner_note_hash(note_interface, *note);\n\n let serialize = note_interface.serialize;\n let preimage = serialize(*note);\n assert(notify_created_note(storage_slot, preimage, inner_note_hash) == 0);\n\n context.push_new_note_hash(inner_note_hash);\n}\n\nfn create_note_hash_from_public(\n context: &mut PublicContext,\n storage_slot: Field,\n note: &mut Note,\n note_interface: NoteInterface,\n) {\n let contract_address = (*context).this_address();\n\n let header = NoteHeader { contract_address, storage_slot, nonce: 0, is_transient: true };\n let set_header = note_interface.set_header;\n set_header(note, header);\n let inner_note_hash = compute_inner_note_hash(note_interface, *note);\n\n context.push_new_note_hash(inner_note_hash);\n}\n\nfn destroy_note(\n context: &mut PrivateContext,\n note: Note,\n note_interface: NoteInterface,\n) {\n let mut nullifier = 0;\n let mut nullified_commitment: Field = EMPTY_NULLIFIED_COMMITMENT;\n let compute_nullifier = note_interface.compute_nullifier;\n nullifier = compute_nullifier(note);\n\n // We also need the note commitment corresponding to the \"nullifier\"\n let get_header = note_interface.get_header;\n let header = get_header(note);\n // `nullified_commitment` is used to inform the kernel which pending commitment\n // the nullifier corresponds to so they can be matched and both squashed/deleted.\n // nonzero nonce implies \"persistable\" nullifier (nullifies a persistent/in-tree\n // commitment) in which case `nullified_commitment` is not used since the kernel\n // just siloes and forwards the nullier to its output.\n if (header.is_transient) {\n // TODO(1718): Can we reuse the note commitment computed in `compute_nullifier`?\n nullified_commitment = compute_inner_note_hash(note_interface, note);\n }\n assert(notify_nullified_note(nullifier, nullified_commitment) == 0);\n\n context.push_new_nullifier(nullifier, nullified_commitment)\n}", + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/aztec/src/note/lifecycle" }, "47": { - "source": "use dep::std::option::Option;\nuse crate::constants_gen::{\n MAX_READ_REQUESTS_PER_CALL,\n GET_NOTE_ORACLE_RETURN_LENGTH,\n GET_NOTES_ORACLE_RETURN_LENGTH,\n MAX_NOTES_PER_PAGE,\n VIEW_NOTE_ORACLE_RETURN_LENGTH,\n};\nuse crate::context::PrivateContext;\nuse crate::note::{\n note_getter_options::{NoteGetterOptions, Select, Sort},\n note_interface::NoteInterface,\n note_header::NoteHeader,\n note_viewer_options::NoteViewerOptions,\n utils::compute_note_hash_for_read_or_nullify,\n utils::compute_inner_note_hash,\n utils::compute_siloed_note_hash,\n};\nuse crate::oracle;\nuse crate::types::vec::BoundedVec;\n\nfn check_note_header(\n context: PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\n note: Note,\n) {\n let get_header = note_interface.get_header;\n let header = get_header(note);\n let contract_address = context.this_address();\n assert(header.contract_address == contract_address);\n assert(header.storage_slot == storage_slot);\n}\n\n// Ensure a note's hash exists in the tree without retrieving the entire\n// notes via the oracle.\nfn ensure_note_hash_exists(\n context: &mut PrivateContext,\n note_interface: NoteInterface,\n note: Note,\n from_public: bool,\n) {\n let get_header = note_interface.get_header;\n let header = get_header(note);\n\n // Check the note hash via oracle and early out if it doesn't exist.\n let inner_note_hash = compute_inner_note_hash(note_interface, note);\n let exists = oracle::notes::check_note_hash_exists(header.nonce, inner_note_hash);\n assert(exists, \"Note hash does not exist.\");\n\n let mut note_hash_for_read_request = compute_note_hash_for_read_or_nullify(note_interface, note);\n if from_public {\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386)\n // Should remove this once public kernel applies nonces.\n note_hash_for_read_request = compute_siloed_note_hash(note_interface, note);\n }\n context.push_read_request(note_hash_for_read_request);\n}\n\nfn get_note(\n context: &mut PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\n) -> Note {\n let note = get_note_internal(storage_slot, note_interface);\n\n check_note_header(*context, storage_slot, note_interface, note);\n\n let note_hash_for_read_request = compute_note_hash_for_read_or_nullify(note_interface, note);\n\n context.push_read_request(note_hash_for_read_request);\n note\n}\n\nfn get_notes(\n context: &mut PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\n options: NoteGetterOptions,\n) -> [Option; MAX_READ_REQUESTS_PER_CALL] {\n let opt_notes = get_notes_internal(storage_slot, note_interface, options);\n for i in 0..opt_notes.len() {\n let opt_note = opt_notes[i];\n if opt_note.is_some() {\n let note = opt_note.unwrap_unchecked();\n check_note_header(*context, storage_slot, note_interface, note);\n\n let note_hash_for_read_request = compute_note_hash_for_read_or_nullify(note_interface, note);\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1410): test to ensure\n // failure if malicious oracle injects 0 nonce here for a \"pre-existing\" note.\n context.push_read_request(note_hash_for_read_request);\n };\n };\n opt_notes\n}\n\nunconstrained fn get_note_internal(\n storage_slot: Field,\n note_interface: NoteInterface,\n) -> Note {\n let placeholder_note = [Option::none()];\n let placeholder_fields = [0; GET_NOTE_ORACLE_RETURN_LENGTH];\n oracle::notes::get_notes(\n storage_slot,\n note_interface,\n 0,\n [],\n [],\n [],\n [],\n 1, // limit\n 0, // offset\n placeholder_note,\n placeholder_fields,\n )[0].unwrap() // Notice: we don't allow dummies to be returned from get_note (singular).\n}\n\nunconstrained fn get_notes_internal(\n storage_slot: Field,\n note_interface: NoteInterface,\n options: NoteGetterOptions,\n) -> [Option; MAX_READ_REQUESTS_PER_CALL] {\n let (num_selects, select_by, select_values, sort_by, sort_order) = flatten_options(options.selects, options.sorts);\n let placeholder_opt_notes = [Option::none(); MAX_READ_REQUESTS_PER_CALL];\n let placeholder_fields = [0; GET_NOTES_ORACLE_RETURN_LENGTH];\n let opt_notes = oracle::notes::get_notes(\n storage_slot,\n note_interface,\n num_selects,\n select_by,\n select_values,\n sort_by,\n sort_order,\n options.limit,\n options.offset,\n placeholder_opt_notes,\n placeholder_fields,\n );\n\n let filter = options.filter;\n let filter_args = options.filter_args;\n filter(opt_notes, filter_args)\n}\n\nunconstrained fn view_notes(\n storage_slot: Field,\n note_interface: NoteInterface,\n options: NoteViewerOptions,\n) -> [Option; MAX_NOTES_PER_PAGE] {\n let (num_selects, select_by, select_values, sort_by, sort_order) = flatten_options(options.selects, options.sorts);\n let placeholder_opt_notes = [Option::none(); MAX_NOTES_PER_PAGE];\n let placeholder_fields = [0; VIEW_NOTE_ORACLE_RETURN_LENGTH];\n oracle::notes::get_notes(\n storage_slot,\n note_interface,\n num_selects,\n select_by,\n select_values,\n sort_by,\n sort_order,\n options.limit,\n options.offset,\n placeholder_opt_notes,\n placeholder_fields,\n )\n}\n\nunconstrained fn flatten_options(\n selects: BoundedVec, N>,\n sorts: BoundedVec, N>,\n) -> (u8, [u8; N], [Field; N], [u8; N], [u2; N]) {\n let mut num_selects = 0;\n let mut select_by = [0; N];\n let mut select_values = [0; N];\n for i in 0..selects.len {\n let select = selects.get(i);\n if select.is_some() {\n select_by[num_selects] = select.unwrap_unchecked().field_index;\n select_values[num_selects] = select.unwrap_unchecked().value;\n num_selects += 1;\n };\n };\n\n let mut sort_by = [0; N];\n let mut sort_order = [0; N];\n for i in 0..sorts.len {\n let sort = sorts.get(i);\n if sort.is_some() {\n sort_by[i] = sort.unwrap_unchecked().field_index;\n sort_order[i] = sort.unwrap_unchecked().order;\n };\n };\n\n (num_selects, select_by, select_values, sort_by, sort_order)\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/note/note_getter" + "source": "use dep::std::option::Option;\nuse crate::constants_gen::{\n MAX_READ_REQUESTS_PER_CALL,\n GET_NOTE_ORACLE_RETURN_LENGTH,\n GET_NOTES_ORACLE_RETURN_LENGTH,\n MAX_NOTES_PER_PAGE,\n VIEW_NOTE_ORACLE_RETURN_LENGTH,\n};\nuse crate::context::PrivateContext;\nuse crate::note::{\n note_getter_options::{NoteGetterOptions, Select, Sort},\n note_interface::NoteInterface,\n note_viewer_options::NoteViewerOptions,\n utils::compute_note_hash_for_read_or_nullify,\n utils::compute_inner_note_hash,\n utils::compute_siloed_note_hash,\n};\nuse crate::oracle;\nuse crate::types::vec::BoundedVec;\n\nfn check_note_header(\n context: PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\n note: Note,\n) {\n let get_header = note_interface.get_header;\n let header = get_header(note);\n let contract_address = context.this_address();\n assert(header.contract_address == contract_address);\n assert(header.storage_slot == storage_slot);\n}\n\nfn get_note(\n context: &mut PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\n) -> Note {\n let note = get_note_internal(storage_slot, note_interface);\n\n check_note_header(*context, storage_slot, note_interface, note);\n\n let note_hash_for_read_request = compute_note_hash_for_read_or_nullify(note_interface, note);\n\n context.push_read_request(note_hash_for_read_request);\n note\n}\n\nfn get_notes(\n context: &mut PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\n options: NoteGetterOptions,\n) -> [Option; MAX_READ_REQUESTS_PER_CALL] {\n let opt_notes = get_notes_internal(storage_slot, note_interface, options);\n for i in 0..opt_notes.len() {\n let opt_note = opt_notes[i];\n if opt_note.is_some() {\n let note = opt_note.unwrap_unchecked();\n check_note_header(*context, storage_slot, note_interface, note);\n\n let note_hash_for_read_request = compute_note_hash_for_read_or_nullify(note_interface, note);\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1410): test to ensure\n // failure if malicious oracle injects 0 nonce here for a \"pre-existing\" note.\n context.push_read_request(note_hash_for_read_request);\n };\n };\n opt_notes\n}\n\nunconstrained fn get_note_internal(\n storage_slot: Field,\n note_interface: NoteInterface,\n) -> Note {\n let placeholder_note = [Option::none()];\n let placeholder_fields = [0; GET_NOTE_ORACLE_RETURN_LENGTH];\n oracle::notes::get_notes(\n storage_slot,\n note_interface,\n 0,\n [],\n [],\n [],\n [],\n 1, // limit\n 0, // offset\n placeholder_note,\n placeholder_fields,\n )[0].unwrap() // Notice: we don't allow dummies to be returned from get_note (singular).\n}\n\nunconstrained fn get_notes_internal(\n storage_slot: Field,\n note_interface: NoteInterface,\n options: NoteGetterOptions,\n) -> [Option; MAX_READ_REQUESTS_PER_CALL] {\n let (num_selects, select_by, select_values, sort_by, sort_order) = flatten_options(options.selects, options.sorts);\n let placeholder_opt_notes = [Option::none(); MAX_READ_REQUESTS_PER_CALL];\n let placeholder_fields = [0; GET_NOTES_ORACLE_RETURN_LENGTH];\n let opt_notes = oracle::notes::get_notes(\n storage_slot,\n note_interface,\n num_selects,\n select_by,\n select_values,\n sort_by,\n sort_order,\n options.limit,\n options.offset,\n placeholder_opt_notes,\n placeholder_fields,\n );\n\n let filter = options.filter;\n let filter_args = options.filter_args;\n filter(opt_notes, filter_args)\n}\n\nunconstrained fn view_notes(\n storage_slot: Field,\n note_interface: NoteInterface,\n options: NoteViewerOptions,\n) -> [Option; MAX_NOTES_PER_PAGE] {\n let (num_selects, select_by, select_values, sort_by, sort_order) = flatten_options(options.selects, options.sorts);\n let placeholder_opt_notes = [Option::none(); MAX_NOTES_PER_PAGE];\n let placeholder_fields = [0; VIEW_NOTE_ORACLE_RETURN_LENGTH];\n oracle::notes::get_notes(\n storage_slot,\n note_interface,\n num_selects,\n select_by,\n select_values,\n sort_by,\n sort_order,\n options.limit,\n options.offset,\n placeholder_opt_notes,\n placeholder_fields,\n )\n}\n\nunconstrained fn flatten_options(\n selects: BoundedVec, N>,\n sorts: BoundedVec, N>,\n) -> (u8, [u8; N], [Field; N], [u8; N], [u2; N]) {\n let mut num_selects = 0;\n let mut select_by = [0; N];\n let mut select_values = [0; N];\n for i in 0..selects.len {\n let select = selects.get(i);\n if select.is_some() {\n select_by[num_selects] = select.unwrap_unchecked().field_index;\n select_values[num_selects] = select.unwrap_unchecked().value;\n num_selects += 1;\n };\n };\n\n let mut sort_by = [0; N];\n let mut sort_order = [0; N];\n for i in 0..sorts.len {\n let sort = sorts.get(i);\n if sort.is_some() {\n sort_by[i] = sort.unwrap_unchecked().field_index;\n sort_order[i] = sort.unwrap_unchecked().order;\n };\n };\n\n (num_selects, select_by, select_values, sort_by, sort_order)\n}", + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/aztec/src/note/note_getter" }, "49": { "source": "use dep::std::hash::{pedersen, pedersen_with_separator};\nuse crate::constants_gen::{GENERATOR_INDEX__UNIQUE_COMMITMENT, GENERATOR_INDEX__SILOED_COMMITMENT};\n\nfn compute_inner_hash(storage_slot: Field, note_hash: Field) -> Field {\n // TODO(#1205) Do we need a generator index here?\n pedersen([storage_slot, note_hash])[0]\n}\n\nfn compute_siloed_hash(contract_address: Field, inner_note_hash: Field) -> Field {\n let inputs = [contract_address, inner_note_hash];\n pedersen_with_separator(inputs, GENERATOR_INDEX__SILOED_COMMITMENT)[0]\n}\n\nfn compute_unique_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n let inputs = [nonce, siloed_note_hash];\n pedersen_with_separator(inputs, GENERATOR_INDEX__UNIQUE_COMMITMENT)[0]\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/note/note_hash" + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/aztec/src/note/note_hash" }, "52": { "source": "use dep::std::option::Option;\nuse crate::constants_gen::MAX_NOTES_PER_PAGE;\nuse crate::note::note_getter_options::{Select, Sort};\nuse crate::types::vec::BoundedVec;\n\n// docs:start:NoteViewerOptions\nstruct NoteViewerOptions {\n selects: BoundedVec, N>,\n sorts: BoundedVec, N>,\n limit: u32,\n offset: u32,\n}\n// docs:end:NoteViewerOptions\n\nimpl NoteViewerOptions {\n fn new() -> NoteViewerOptions {\n NoteViewerOptions {\n selects: BoundedVec::new(Option::none()),\n sorts: BoundedVec::new(Option::none()),\n limit: MAX_NOTES_PER_PAGE as u32,\n offset: 0,\n }\n }\n\n fn select(&mut self, field_index: u8, value: Field) -> Self {\n self.selects.push(Option::some(Select::new(field_index, value)));\n *self\n }\n\n fn sort(&mut self, field_index: u8, order: u2) -> Self {\n self.sorts.push(Option::some(Sort::new(field_index, order)));\n *self\n }\n\n fn set_limit(&mut self, limit: u32) -> Self {\n assert(limit <= MAX_NOTES_PER_PAGE as u32);\n self.limit = limit;\n *self\n }\n\n fn set_offset(&mut self, offset: u32) -> Self {\n self.offset = offset;\n *self\n }\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/note/note_viewer_options" + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/aztec/src/note/note_viewer_options" }, "53": { - "source": "use crate::note::{\n note_hash::{compute_inner_hash, compute_siloed_hash, compute_unique_hash},\n note_header::NoteHeader,\n note_interface::NoteInterface,\n};\nuse crate::utils::arr_copy_slice;\n\nfn compute_inner_note_hash(\n note_interface: NoteInterface,\n note: Note,\n) -> Field {\n let get_header = note_interface.get_header;\n let header = get_header(note);\n\n let compute_note_hash = note_interface.compute_note_hash;\n let note_hash = compute_note_hash(note);\n\n compute_inner_hash(header.storage_slot, note_hash)\n}\n\nfn compute_siloed_note_hash(\n note_interface: NoteInterface,\n note_with_header: Note,\n) -> Field {\n let get_header = note_interface.get_header;\n let header = get_header(note_with_header);\n\n let inner_note_hash = compute_inner_note_hash(note_interface, note_with_header);\n\n compute_siloed_hash(header.contract_address, inner_note_hash)\n}\n\nfn compute_unique_siloed_note_hash(\n note_interface: NoteInterface,\n note_with_header: Note,\n) -> Field {\n let get_header = note_interface.get_header;\n let header = get_header(note_with_header);\n\n let siloed_note_hash = compute_siloed_note_hash(note_interface, note_with_header);\n\n compute_unique_hash(header.nonce, siloed_note_hash)\n}\n\nfn compute_note_hash_for_read_or_nullify(\n note_interface: NoteInterface,\n note_with_header: Note,\n) -> Field {\n let get_header = note_interface.get_header;\n let header = get_header(note_with_header);\n\n if (header.nonce == 0) {\n // when nonce is zero, that means we are reading a pending note (doesn't have a nonce yet),\n // so we just read the inner_note_hash (kernel will silo by contract address)\n compute_inner_note_hash(note_interface, note_with_header)\n } else {\n // When nonce is nonzero, that means we are reading a settled note (from tree) created in a\n // previous TX. So we need the unique_siloed_note_hash which has already been hashed with\n // contract address and then nonce. This hash will match the existing leaf in the private\n // data tree, so the kernel can just perform a membership check directly on this hash/leaf.\n compute_unique_siloed_note_hash(note_interface, note_with_header)\n }\n\n}\n\nfn compute_note_hash_and_nullifier(\n note_interface: NoteInterface,\n note_header: NoteHeader,\n preimage: [Field; S],\n) -> [Field; 4] {\n let deserialise = note_interface.deserialise;\n let set_header = note_interface.set_header;\n let mut note = deserialise(arr_copy_slice(preimage, [0; N], 0));\n set_header(&mut note, note_header);\n\n let compute_note_hash = note_interface.compute_note_hash;\n let note_hash = compute_note_hash(note);\n let inner_note_hash = compute_inner_hash(note_header.storage_slot, note_hash);\n\n let siloed_note_hash = compute_siloed_hash(note_header.contract_address, inner_note_hash);\n\n let unique_siloed_note_hash = compute_unique_hash(note_header.nonce, siloed_note_hash);\n\n let compute_nullifier = note_interface.compute_nullifier;\n let inner_nullifier = compute_nullifier(note);\n\n [inner_note_hash, siloed_note_hash, unique_siloed_note_hash, inner_nullifier]\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/note/utils" + "source": "use crate::note::{\n note_hash::{compute_inner_hash, compute_siloed_hash, compute_unique_hash},\n note_header::NoteHeader,\n note_interface::NoteInterface,\n};\nuse crate::utils::arr_copy_slice;\n\nfn compute_inner_note_hash(\n note_interface: NoteInterface,\n note: Note,\n) -> Field {\n let get_header = note_interface.get_header;\n let header = get_header(note);\n\n let compute_note_hash = note_interface.compute_note_hash;\n let note_hash = compute_note_hash(note);\n\n compute_inner_hash(header.storage_slot, note_hash)\n}\n\nfn compute_siloed_note_hash(\n note_interface: NoteInterface,\n note_with_header: Note,\n) -> Field {\n let get_header = note_interface.get_header;\n let header = get_header(note_with_header);\n\n let inner_note_hash = compute_inner_note_hash(note_interface, note_with_header);\n\n compute_siloed_hash(header.contract_address, inner_note_hash)\n}\n\nfn compute_unique_siloed_note_hash(\n note_interface: NoteInterface,\n note_with_header: Note,\n) -> Field {\n let get_header = note_interface.get_header;\n let header = get_header(note_with_header);\n\n let siloed_note_hash = compute_siloed_note_hash(note_interface, note_with_header);\n\n compute_unique_hash(header.nonce, siloed_note_hash)\n}\n\nfn compute_note_hash_for_read_or_nullify(\n note_interface: NoteInterface,\n note_with_header: Note,\n) -> Field {\n let get_header = note_interface.get_header;\n let header = get_header(note_with_header);\n\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386)\n if (header.is_transient) {\n // If a note is transient, we just read the inner_note_hash (kernel will silo by contract address).\n compute_inner_note_hash(note_interface, note_with_header)\n } else if (header.nonce == 0) {\n // If not transient and nonce is zero, that means we are reading a public note.\n compute_siloed_note_hash(note_interface, note_with_header)\n } else {\n // When nonce is nonzero, that means we are reading a settled note (from tree) created in a\n // previous TX. So we need the unique_siloed_note_hash which has already been hashed with\n // contract address and then nonce. This hash will match the existing leaf in the private\n // data tree, so the kernel can just perform a membership check directly on this hash/leaf.\n compute_unique_siloed_note_hash(note_interface, note_with_header)\n }\n\n}\n\nfn compute_note_hash_and_nullifier(\n note_interface: NoteInterface,\n note_header: NoteHeader,\n preimage: [Field; S],\n) -> [Field; 4] {\n let deserialize = note_interface.deserialize;\n let set_header = note_interface.set_header;\n let mut note = deserialize(arr_copy_slice(preimage, [0; N], 0));\n set_header(&mut note, note_header);\n\n let compute_note_hash = note_interface.compute_note_hash;\n let note_hash = compute_note_hash(note);\n let inner_note_hash = compute_inner_hash(note_header.storage_slot, note_hash);\n\n let siloed_note_hash = compute_siloed_hash(note_header.contract_address, inner_note_hash);\n\n let unique_siloed_note_hash = compute_unique_hash(note_header.nonce, siloed_note_hash);\n\n let compute_nullifier = note_interface.compute_nullifier;\n let inner_nullifier = compute_nullifier(note);\n\n [inner_note_hash, siloed_note_hash, unique_siloed_note_hash, inner_nullifier]\n}\n", + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/aztec/src/note/utils" }, "60": { "source": "use crate::types::point::Point;\nuse crate::address::compute_address;\n\n#[oracle(getPublicKey)]\nfn get_public_key_oracle(_address: Field) -> [Field; 3] {}\n\nunconstrained fn get_public_key_internal(address: Field) -> [Field; 3] {\n get_public_key_oracle(address)\n}\n\nfn get_public_key(address: Field) -> Point {\n let result = get_public_key_internal(address);\n let pub_key_x = result[0];\n let pub_key_y = result[1];\n let partial_address = result[2];\n \n let calculated_address = compute_address(pub_key_x, pub_key_y, partial_address);\n assert(calculated_address == address);\n \n Point::new(pub_key_x, pub_key_y)\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/oracle/get_public_key" + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/aztec/src/oracle/get_public_key" }, "61": { "source": "use crate::oracle::get_public_key::get_public_key;\nuse crate::types::point::Point;\n\n#[oracle(getSecretKey)]\nfn get_secret_key_oracle(\n _owner: Point,\n) -> [Field; dep::std::grumpkin_scalar::GRUMPKIN_SCALAR_SERIALIZED_LEN] {\n}\n\nunconstrained fn get_secret_key_internal(owner_public_key: Point) -> dep::std::grumpkin_scalar::GrumpkinScalar {\n dep::std::grumpkin_scalar::deserialize_grumpkin_scalar(get_secret_key_oracle(owner_public_key))\n}\n\nfn get_secret_key(owner: Field) -> dep::std::grumpkin_scalar::GrumpkinScalar {\n let owner_public_key = get_public_key(owner);\n let secret = get_secret_key_internal(owner_public_key);\n\n // Constrain the owner - Nullifier secret key is currently just the encryption private key so we can constrain\n // the owner by deriving the public key from the secret key and checking the result.\n let computed_public_key = dep::std::grumpkin_scalar_mul::grumpkin_fixed_base(secret);\n assert(owner_public_key.x == computed_public_key[0]);\n assert(owner_public_key.y == computed_public_key[1]);\n\n secret\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/oracle/get_secret_key" + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/aztec/src/oracle/get_secret_key" }, "62": { "source": "\n\n#[oracle(getRandomField)]\nfn rand_oracle() -> Field {}\n\nunconstrained fn rand() -> Field {\n rand_oracle()\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/oracle/rand" + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/aztec/src/oracle/rand" }, "65": { - "source": "use dep::std::option::Option;\nuse crate::note::{\n note_header::NoteHeader,\n note_interface::NoteInterface,\n};\nuse crate::utils::arr_copy_slice;\n\n#[oracle(notifyCreatedNote)]\nfn notify_created_note_oracle(\n _storage_slot: Field,\n _preimage: [Field; N],\n _inner_note_hash: Field,\n) -> Field {}\n\nunconstrained fn notify_created_note(\n storage_slot: Field,\n preimage: [Field; N],\n inner_note_hash: Field,\n) -> Field {\n notify_created_note_oracle(storage_slot, preimage, inner_note_hash)\n}\n\n#[oracle(notifyNullifiedNote)]\nfn notify_nullified_note_oracle(\n _nullifier: Field,\n _inner_note_hash: Field,\n) -> Field {}\n\nunconstrained fn notify_nullified_note(\n nullifier: Field,\n inner_note_hash: Field,\n) -> Field {\n notify_nullified_note_oracle(nullifier, inner_note_hash)\n}\n\n#[oracle(checkNoteHashExists)]\nfn check_note_hash_exists_oracle(\n _nonce: Field,\n _inner_note_hash: Field,\n) -> Field {}\n\nunconstrained fn check_note_hash_exists(\n nonce: Field,\n inner_note_hash: Field,\n) -> bool {\n check_note_hash_exists_oracle(nonce, inner_note_hash) == 1\n}\n\n#[oracle(getNotes)]\nfn get_notes_oracle(\n _storage_slot: Field,\n _num_selects: u8,\n _select_by: [u8; N],\n _select_values: [Field; N],\n _sort_by: [u8; N],\n _sort_order: [u2; N],\n _limit: u32,\n _offset: u32,\n _return_size: u32,\n _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper(\n storage_slot: Field,\n num_selects: u8,\n select_by: [u8; N],\n select_values: [Field; N],\n sort_by: [u8; N],\n sort_order: [u2; N],\n limit: u32,\n offset: u32,\n mut placeholder_fields: [Field; S],\n)-> [Field; S] {\n let return_size = placeholder_fields.len() as u32;\n get_notes_oracle(storage_slot, num_selects, select_by, select_values, sort_by, sort_order, limit, offset, return_size, placeholder_fields)\n}\n\nunconstrained fn get_notes(\n storage_slot: Field,\n note_interface: NoteInterface,\n num_selects: u8,\n select_by: [u8; M],\n select_values: [Field; M],\n sort_by: [u8; M],\n sort_order: [u2; M],\n limit: u32,\n offset: u32,\n mut placeholder_opt_notes: [Option; S], // TODO: Remove it and use `limit` to initialise the note array.\n placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialise the note array.\n) -> [Option; S] {\n let fields = get_notes_oracle_wrapper(storage_slot, num_selects, select_by, select_values, sort_by, sort_order, limit, offset, placeholder_fields);\n let num_notes = fields[0] as u32;\n let contract_address = fields[1];\n let deserialise = note_interface.deserialise;\n let set_header = note_interface.set_header;\n for i in 0..placeholder_opt_notes.len() {\n if i as u32 < num_notes {\n // lengths named as per typescript.\n let return_header_length: Field = 2; // num_notes & contract_address.\n let extra_preimage_length: Field = 2; // nonce & is_some.\n let read_offset: Field = return_header_length + i * (N + extra_preimage_length);\n let nonce = fields[read_offset];\n let header = NoteHeader { contract_address, nonce, storage_slot };\n let is_some = fields[read_offset + 1] as bool;\n if is_some {\n let preimage = arr_copy_slice(fields, [0; N], read_offset + 2);\n let mut note = deserialise(preimage);\n set_header(&mut note, header);\n placeholder_opt_notes[i] = Option::some(note);\n }\n };\n };\n placeholder_opt_notes\n}\n\nunconstrained fn is_nullifier_emitted(nullifier: Field) -> bool {\n // TODO\n nullifier == 0\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/oracle/notes" + "source": "use dep::std::option::Option;\nuse crate::note::{\n note_header::NoteHeader,\n note_interface::NoteInterface,\n};\nuse crate::utils::arr_copy_slice;\n\n#[oracle(notifyCreatedNote)]\nfn notify_created_note_oracle(\n _storage_slot: Field,\n _preimage: [Field; N],\n _inner_note_hash: Field,\n) -> Field {}\n\nunconstrained fn notify_created_note(\n storage_slot: Field,\n preimage: [Field; N],\n inner_note_hash: Field,\n) -> Field {\n notify_created_note_oracle(storage_slot, preimage, inner_note_hash)\n}\n\n#[oracle(notifyNullifiedNote)]\nfn notify_nullified_note_oracle(\n _nullifier: Field,\n _inner_note_hash: Field,\n) -> Field {}\n\nunconstrained fn notify_nullified_note(\n nullifier: Field,\n inner_note_hash: Field,\n) -> Field {\n notify_nullified_note_oracle(nullifier, inner_note_hash)\n}\n\n#[oracle(getNotes)]\nfn get_notes_oracle(\n _storage_slot: Field,\n _num_selects: u8,\n _select_by: [u8; N],\n _select_values: [Field; N],\n _sort_by: [u8; N],\n _sort_order: [u2; N],\n _limit: u32,\n _offset: u32,\n _return_size: u32,\n _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper(\n storage_slot: Field,\n num_selects: u8,\n select_by: [u8; N],\n select_values: [Field; N],\n sort_by: [u8; N],\n sort_order: [u2; N],\n limit: u32,\n offset: u32,\n mut placeholder_fields: [Field; S],\n)-> [Field; S] {\n let return_size = placeholder_fields.len() as u32;\n get_notes_oracle(storage_slot, num_selects, select_by, select_values, sort_by, sort_order, limit, offset, return_size, placeholder_fields)\n}\n\nunconstrained fn get_notes(\n storage_slot: Field,\n note_interface: NoteInterface,\n num_selects: u8,\n select_by: [u8; M],\n select_values: [Field; M],\n sort_by: [u8; M],\n sort_order: [u2; M],\n limit: u32,\n offset: u32,\n mut placeholder_opt_notes: [Option; S], // TODO: Remove it and use `limit` to initialize the note array.\n placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n) -> [Option; S] {\n let fields = get_notes_oracle_wrapper(storage_slot, num_selects, select_by, select_values, sort_by, sort_order, limit, offset, placeholder_fields);\n let num_notes = fields[0] as u32;\n let contract_address = fields[1];\n let deserialize = note_interface.deserialize;\n let set_header = note_interface.set_header;\n for i in 0..placeholder_opt_notes.len() {\n if i as u32 < num_notes {\n // lengths named as per typescript.\n let return_header_length: Field = 2; // num_notes & contract_address.\n let extra_preimage_length: Field = 2; // nonce & is_transient.\n let read_offset: Field = return_header_length + i * (N + extra_preimage_length);\n let nonce = fields[read_offset];\n let is_transient = fields[read_offset + 1] as bool;\n let header = NoteHeader { contract_address, nonce, storage_slot, is_transient };\n let preimage = arr_copy_slice(fields, [0; N], read_offset + 2);\n let mut note = deserialize(preimage);\n set_header(&mut note, header);\n placeholder_opt_notes[i] = Option::some(note);\n };\n };\n placeholder_opt_notes\n}\n\nunconstrained fn is_nullifier_emitted(nullifier: Field) -> bool {\n // TODO\n nullifier == 0\n}", + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/aztec/src/oracle/notes" }, "67": { "source": "use crate::types::point::Point;\nuse crate::constants_gen::NUM_FIELDS_PER_SHA256;\n\n// TODO: Should take encrypted data.\n#[oracle(emitEncryptedLog)]\nfn emit_encrypted_log_oracle(\n _contract_address: Field,\n _storage_slot: Field,\n _encryption_pub_key: Point,\n _preimage: [Field; N],\n) -> Field {}\n\nunconstrained fn emit_encrypted_log(\n contract_address: Field,\n storage_slot: Field,\n encryption_pub_key: Point,\n preimage: [Field; N],\n) -> [Field; NUM_FIELDS_PER_SHA256] {\n [emit_encrypted_log_oracle(\n contract_address,\n storage_slot,\n encryption_pub_key,\n preimage,\n ), 0]\n}\n\n#[oracle(emitUnencryptedLog)]\nfn emit_unencrypted_log_oracle(_message: T) -> Field {}\n\nunconstrained fn emit_unencrypted_log(message: T) -> [Field; NUM_FIELDS_PER_SHA256] {\n // https://github.com/AztecProtocol/aztec-packages/issues/885\n [emit_unencrypted_log_oracle(message), 0]\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/oracle/logs" + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/aztec/src/oracle/logs" }, "74": { - "source": "use crate::context::{PrivateContext, PublicContext, Context};\nuse dep::std::option::Option;\n\nstruct Map {\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n}\n\nimpl Map {\n fn new(\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n ) -> Map {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n Map {\n context,\n storage_slot,\n state_var_constructor,\n }\n }\n\n fn at(self, key: Field) -> V {\n // TODO(#1204): use a generator index for the storage slot\n let derived_storage_slot = dep::std::hash::pedersen([self.storage_slot, key])[0];\n\n let state_var_constructor = self.state_var_constructor;\n state_var_constructor(self.context, derived_storage_slot)\n }\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/state_vars/map" + "source": "use crate::context::{PrivateContext, PublicContext, Context};\nuse dep::std::option::Option;\n\n// docs:start:map\nstruct Map {\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl Map {\n // docs:start:new\n fn new(\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n ) -> Map {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n Map {\n context,\n storage_slot,\n state_var_constructor,\n }\n }\n // docs:end:new\n\n // docs:start:at\n fn at(self, key: Field) -> V {\n // TODO(#1204): use a generator index for the storage slot\n let derived_storage_slot = dep::std::hash::pedersen([self.storage_slot, key])[0];\n\n let state_var_constructor = self.state_var_constructor;\n state_var_constructor(self.context, derived_storage_slot)\n }\n // docs:end:at\n}\n", + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/aztec/src/state_vars/map" }, "76": { - "source": "use dep::std::option::Option;\nuse crate::abi::PublicContextInputs;\nuse crate::constants_gen::{MAX_NOTES_PER_PAGE, MAX_READ_REQUESTS_PER_CALL};\nuse crate::context::{PrivateContext, PublicContext, Context};\nuse crate::note::{\n lifecycle::{create_note, create_note_hash_from_public, destroy_note},\n note_getter::{ensure_note_hash_exists, get_notes, view_notes},\n note_getter_options::NoteGetterOptions,\n note_header::NoteHeader,\n note_interface::NoteInterface,\n note_viewer_options::NoteViewerOptions,\n utils::compute_note_hash_for_read_or_nullify,\n};\n\nstruct Set {\n context: Context,\n storage_slot: Field,\n note_interface: NoteInterface,\n}\n\nimpl Set {\n fn new(\n context: Context,\n storage_slot: Field,\n note_interface: NoteInterface,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n Set {\n context,\n storage_slot,\n note_interface,\n }\n }\n\n fn insert(self, note: &mut Note) {\n create_note(\n self.context.private.unwrap(),\n self.storage_slot,\n note,\n self.note_interface,\n );\n }\n\n fn insert_from_public(self, note: &mut Note) {\n create_note_hash_from_public(\n self.context.public.unwrap(),\n self.storage_slot,\n note,\n self.note_interface,\n );\n }\n\n fn assert_contains_and_remove(self, note: &mut Note, nonce: Field) {\n // Initialize header of note. Must be done before computing note hashes as it initializes the:\n // - storage slot (used in inner note hash)\n // - the contract address (used in siloed note hash)\n // - and the nonce (used in the unique siloed note hash)\n let context = self.context.private.unwrap();\n let set_header = self.note_interface.set_header;\n let note_header = NoteHeader{\n contract_address: context.this_address(),\n storage_slot: self.storage_slot,\n nonce\n };\n set_header(note, note_header);\n\n ensure_note_hash_exists(\n context,\n self.note_interface,\n *note,\n false,\n );\n\n destroy_note(\n context,\n *note,\n self.note_interface,\n );\n }\n\n // NOTE: this function should ONLY be used for PUBLICLY-CREATED note hashes!\n // WARNING: function will be deprecated/removed eventually once public kernel applies nonces.\n fn assert_contains_and_remove_publicly_created(self, note: &mut Note) {\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386)\n // Should be real nonce (once public kernel applies nonces).\n let nonce = 0;\n let context = self.context.private.unwrap();\n let set_header = self.note_interface.set_header;\n let mut note_header = NoteHeader{\n contract_address: context.this_address(),\n storage_slot: self.storage_slot,\n nonce\n };\n set_header(note, note_header);\n\n ensure_note_hash_exists(\n context,\n self.note_interface,\n *note,\n true,\n );\n\n // Set the nonce to nonzero so that the nullifier is treated as persistable\n // (non-transient) and so the private kernel does not attempt to match it to\n // a pending noteHash/commitment and squash them.\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386): remove\n // this hack once public kernel injects nonces.\n note_header.nonce = 1;\n set_header(note, note_header);\n\n destroy_note(\n context,\n *note,\n self.note_interface,\n );\n }\n\n fn remove(self, note: Note) {\n let context = self.context.private.unwrap();\n let note_hash = compute_note_hash_for_read_or_nullify(self.note_interface, note);\n let has_been_read = context.read_requests.any(|r| r == note_hash);\n assert(has_been_read, \"Can only remove a note that has been read from the set.\");\n\n destroy_note(\n context,\n note,\n self.note_interface,\n );\n }\n\n fn get_notes(\n self,\n options: NoteGetterOptions,\n ) -> [Option; MAX_READ_REQUESTS_PER_CALL] {\n let storage_slot = self.storage_slot;\n let opt_notes = get_notes(\n self.context.private.unwrap(),\n storage_slot,\n self.note_interface,\n options,\n );\n opt_notes\n }\n\n unconstrained fn view_notes(\n self,\n options: NoteViewerOptions,\n ) -> [Option; MAX_NOTES_PER_PAGE] {\n view_notes(self.storage_slot, self.note_interface, options)\n }\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/state_vars/set" + "source": "use dep::std::option::Option;\nuse crate::abi::PublicContextInputs;\nuse crate::constants_gen::{MAX_NOTES_PER_PAGE, MAX_READ_REQUESTS_PER_CALL};\nuse crate::context::{PrivateContext, PublicContext, Context};\nuse crate::note::{\n lifecycle::{create_note, create_note_hash_from_public, destroy_note},\n note_getter::{get_notes, view_notes},\n note_getter_options::NoteGetterOptions,\n note_header::NoteHeader,\n note_interface::NoteInterface,\n note_viewer_options::NoteViewerOptions,\n utils::compute_note_hash_for_read_or_nullify,\n};\n\n// docs:start:struct\nstruct Set {\n context: Context,\n storage_slot: Field,\n note_interface: NoteInterface,\n}\n// docs:end:struct\n\nimpl Set {\n // docs:start:new\n fn new(\n context: Context,\n storage_slot: Field,\n note_interface: NoteInterface,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n Set {\n context,\n storage_slot,\n note_interface,\n }\n }\n // docs:end:new\n\n // docs:start:insert\n fn insert(self, note: &mut Note) {\n create_note(\n self.context.private.unwrap(),\n self.storage_slot,\n note,\n self.note_interface,\n );\n }\n // docs:end:insert\n\n // docs:start:insert_from_public\n fn insert_from_public(self, note: &mut Note) {\n create_note_hash_from_public(\n self.context.public.unwrap(),\n self.storage_slot,\n note,\n self.note_interface,\n );\n }\n // docs:end:insert_from_public\n \n // DEPRECATED\n fn assert_contains_and_remove(_self: Self, _note: &mut Note, _nonce: Field) {\n assert(false, \"`assert_contains_and_remove` has been deprecated. Please call PXE.addNote() to add a note to the database. Then use Set.get_notes() and Set.remove() in your contract to verify and remove a note.\");\n }\n\n // DEPRECATED\n fn assert_contains_and_remove_publicly_created(_self: Self, _note: &mut Note) {\n assert(false, \"`assert_contains_and_remove_publicly_created` has been deprecated. Please call PXE.addNote() to add a note to the database. Then use Set.get_notes() and Set.remove() in your contract to verify and remove a note.\");\n }\n\n // docs:start:remove\n fn remove(self, note: Note) {\n let context = self.context.private.unwrap();\n let note_hash = compute_note_hash_for_read_or_nullify(self.note_interface, note);\n let has_been_read = context.read_requests.any(|r| r == note_hash);\n assert(has_been_read, \"Can only remove a note that has been read from the set.\");\n\n destroy_note(\n context,\n note,\n self.note_interface,\n );\n }\n // docs:end:remove\n\n // docs:start:get_notes\n fn get_notes(\n self,\n options: NoteGetterOptions,\n ) -> [Option; MAX_READ_REQUESTS_PER_CALL] {\n let storage_slot = self.storage_slot;\n let opt_notes = get_notes(\n self.context.private.unwrap(),\n storage_slot,\n self.note_interface,\n options,\n );\n opt_notes\n }\n // docs:end:get_notes\n\n // docs:start:view_notes\n unconstrained fn view_notes(\n self,\n options: NoteViewerOptions,\n ) -> [Option; MAX_NOTES_PER_PAGE] {\n view_notes(self.storage_slot, self.note_interface, options)\n }\n // docs:end:view_notes\n}\n", + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/aztec/src/state_vars/set" }, - "80": { - "source": "\nstruct BoundedVec {\n storage: [T; MaxLen],\n len: Field,\n}\n\nimpl BoundedVec {\n fn new(initial_value: T) -> Self {\n BoundedVec { storage: [initial_value; MaxLen], len: 0 }\n }\n\n fn get(mut self: Self, index: Field) -> T {\n assert(index as u64 < self.len as u64);\n self.storage[index]\n }\n\n fn push(&mut self, elem: T) {\n assert(self.len as u64 < MaxLen as u64);\n\n self.storage[self.len] = elem;\n self.len += 1;\n }\n\n fn push_array(&mut self, array: [T; Len]) {\n let newLen = self.len + array.len();\n assert(newLen as u64 <= MaxLen as u64);\n for i in 0..array.len() {\n self.storage[self.len + i] = array[i];\n }\n self.len = newLen;\n }\n\n fn pop(&mut self) -> T {\n assert(self.len as u64 > 0);\n\n let elem = self.storage[self.len - 1];\n self.len -= 1;\n elem\n }\n\n fn any(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n let mut exceeded_len = false;\n for i in 0..MaxLen {\n exceeded_len |= i == self.len;\n if (!exceeded_len) {\n ret |= predicate(self.storage[i]);\n }\n }\n ret\n }\n}\n\n#[test]\nfn test_vec_push_pop() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n assert(vec.len == 0);\n vec.push(2);\n assert(vec.len == 1);\n vec.push(4);\n assert(vec.len == 2);\n vec.push(6);\n assert(vec.len == 3);\n let x = vec.pop();\n assert(x == 6);\n assert(vec.len == 2);\n assert(vec.get(0) == 2);\n assert(vec.get(1) == 4);\n}\n\n#[test]\nfn test_vec_push_array() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n vec.push_array([2, 4]);\n assert(vec.len == 2);\n assert(vec.get(0) == 2);\n assert(vec.get(1) == 4);\n}\n\n#[test(should_fail)]\nfn test_vec_get_out_of_bound() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n vec.push_array([2, 4]);\n let _x = vec.get(2);\n}\n\n#[test(should_fail)]\nfn test_vec_get_not_declared() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n vec.push_array([2]);\n let _x = vec.get(1);\n}\n\n#[test(should_fail)]\nfn test_vec_get_uninitialised() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n let _x = vec.get(0);\n}\n\n#[test(should_fail)]\nfn test_vec_push_overflow() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n vec.push(1);\n vec.push(2);\n}\n\n#[test]\nfn test_vec_any() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n vec.push_array([2, 4, 6]);\n assert(vec.any(|v| v == 2) == true);\n assert(vec.any(|v| v == 4) == true);\n assert(vec.any(|v| v == 6) == true);\n assert(vec.any(|v| v == 3) == false);\n}\n\n#[test]\nfn test_vec_any_not_default() {\n let default_value = 1;\n let mut vec: BoundedVec = BoundedVec::new(default_value);\n vec.push_array([2, 4]);\n assert(vec.any(|v| v == default_value) == false);\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/types/vec" + "81": { + "source": "\nstruct BoundedVec {\n storage: [T; MaxLen],\n len: Field,\n}\n\nimpl BoundedVec {\n fn new(initial_value: T) -> Self {\n BoundedVec { storage: [initial_value; MaxLen], len: 0 }\n }\n\n fn get(mut self: Self, index: Field) -> T {\n assert(index as u64 < self.len as u64);\n self.storage[index]\n }\n\n fn push(&mut self, elem: T) {\n assert(self.len as u64 < MaxLen as u64);\n\n self.storage[self.len] = elem;\n self.len += 1;\n }\n\n fn push_array(&mut self, array: [T; Len]) {\n let newLen = self.len + array.len();\n assert(newLen as u64 <= MaxLen as u64);\n for i in 0..array.len() {\n self.storage[self.len + i] = array[i];\n }\n self.len = newLen;\n }\n\n fn pop(&mut self) -> T {\n assert(self.len as u64 > 0);\n\n let elem = self.storage[self.len - 1];\n self.len -= 1;\n elem\n }\n\n fn any(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n let mut exceeded_len = false;\n for i in 0..MaxLen {\n exceeded_len |= i == self.len;\n if (!exceeded_len) {\n ret |= predicate(self.storage[i]);\n }\n }\n ret\n }\n}\n\n#[test]\nfn test_vec_push_pop() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n assert(vec.len == 0);\n vec.push(2);\n assert(vec.len == 1);\n vec.push(4);\n assert(vec.len == 2);\n vec.push(6);\n assert(vec.len == 3);\n let x = vec.pop();\n assert(x == 6);\n assert(vec.len == 2);\n assert(vec.get(0) == 2);\n assert(vec.get(1) == 4);\n}\n\n#[test]\nfn test_vec_push_array() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n vec.push_array([2, 4]);\n assert(vec.len == 2);\n assert(vec.get(0) == 2);\n assert(vec.get(1) == 4);\n}\n\n#[test(should_fail)]\nfn test_vec_get_out_of_bound() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n vec.push_array([2, 4]);\n let _x = vec.get(2);\n}\n\n#[test(should_fail)]\nfn test_vec_get_not_declared() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n vec.push_array([2]);\n let _x = vec.get(1);\n}\n\n#[test(should_fail)]\nfn test_vec_get_uninitialized() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n let _x = vec.get(0);\n}\n\n#[test(should_fail)]\nfn test_vec_push_overflow() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n vec.push(1);\n vec.push(2);\n}\n\n#[test]\nfn test_vec_any() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n vec.push_array([2, 4, 6]);\n assert(vec.any(|v| v == 2) == true);\n assert(vec.any(|v| v == 4) == true);\n assert(vec.any(|v| v == 6) == true);\n assert(vec.any(|v| v == 3) == false);\n}\n\n#[test]\nfn test_vec_any_not_default() {\n let default_value = 1;\n let mut vec: BoundedVec = BoundedVec::new(default_value);\n vec.push_array([2, 4]);\n assert(vec.any(|v| v == default_value) == false);\n}", + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/aztec/src/types/vec" }, - "85": { + "87": { "source": "fn arr_copy_slice(\n src: [T; N],\n mut dst: [T; M],\n offset: Field,\n) -> [T; M] {\n for i in 0..dst.len() {\n dst[i] = src[i + offset];\n }\n dst\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/utils" + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/aztec/src/utils" }, - "86": { - "source": "use dep::aztec::note::{\n note_getter::view_notes,\n note_viewer_options::NoteViewerOptions,\n};\nuse dep::aztec::state_vars::set::Set;\nuse crate::value_note::{VALUE_NOTE_LEN, ValueNote};\n\nunconstrained fn get_balance(set: Set) -> Field {\n get_balance_with_offset(set, 0)\n}\n\nunconstrained fn get_balance_with_offset(set: Set, offset: u32) -> Field {\n let mut balance = 0;\n\n let options = NoteViewerOptions::new().set_offset(offset);\n let opt_notes = set.view_notes(options);\n let len = opt_notes.len();\n for i in 0..len {\n if opt_notes[i].is_some() {\n balance += opt_notes[i].unwrap_unchecked().value;\n }\n }\n if (opt_notes[len - 1].is_some()) {\n balance += get_balance_with_offset(set, offset + opt_notes.len() as u32);\n }\n\n balance\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/value-note/src/balance_utils" + "88": { + "source": "use dep::aztec::note::{\n note_getter::view_notes,\n note_viewer_options::NoteViewerOptions,\n};\nuse dep::aztec::state_vars::set::Set;\nuse crate::value_note::{VALUE_NOTE_LEN, ValueNote};\n\nunconstrained fn get_balance(set: Set) -> Field {\n get_balance_with_offset(set, 0)\n}\n\nunconstrained fn get_balance_with_offset(set: Set, offset: u32) -> Field {\n let mut balance = 0;\n // docs:start:view_notes\n let options = NoteViewerOptions::new().set_offset(offset);\n let opt_notes = set.view_notes(options);\n // docs:end:view_notes\n let len = opt_notes.len();\n for i in 0..len {\n if opt_notes[i].is_some() {\n balance += opt_notes[i].unwrap_unchecked().value;\n }\n }\n if (opt_notes[len - 1].is_some()) {\n balance += get_balance_with_offset(set, offset + opt_notes.len() as u32);\n }\n\n balance\n}", + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/value-note/src/balance_utils" }, - "87": { + "89": { "source": "use dep::std::option::Option;\nuse dep::aztec::constants_gen::MAX_READ_REQUESTS_PER_CALL;\nuse crate::value_note::ValueNote;\n\nfn filter_notes_min_sum(notes: [Option; MAX_READ_REQUESTS_PER_CALL], min_sum: Field) -> [Option; MAX_READ_REQUESTS_PER_CALL] {\n let mut selected = [Option::none(); MAX_READ_REQUESTS_PER_CALL];\n let mut sum = 0;\n for i in 0..notes.len() {\n if notes[i].is_some() & (sum < min_sum as u120) {\n let note = notes[i].unwrap_unchecked();\n selected[i] = Option::some(note);\n sum += note.value as u120;\n }\n }\n selected\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/value-note/src/filter" + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/value-note/src/filter" }, - "88": { - "source": "use dep::std::option::Option;\nuse dep::aztec::context::PrivateContext;\n// docs:start:encrypted_import\n\nuse dep::aztec::log::emit_encrypted_log;\n\n// docs:end:encrypted_import\nuse dep::aztec::note::note_getter_options::{NoteGetterOptions, SortOrder};\nuse dep::aztec::oracle::get_public_key::get_public_key;\nuse dep::aztec::state_vars::set::Set;\nuse crate::{\n filter::filter_notes_min_sum,\n value_note::{ValueNote, VALUE_NOTE_LEN},\n};\n\n// Sort the note values (0th field) in descending order.\n// Pick the fewest notes whose sum is equal to or greater than `amount`.\nfn create_note_getter_options_for_decreasing_balance(amount: Field) -> NoteGetterOptions {\n NoteGetterOptions::with_filter(filter_notes_min_sum, amount).sort(0, SortOrder.DESC)\n}\n\n// Creates a new note for the recipient.\n// Inserts it to the recipient's set of notes.\nfn increment(\n balance: Set,\n amount: Field,\n recipient: Field,\n) {\n let mut note = ValueNote::new(amount, recipient);\n create_note(balance, recipient, &mut note);\n\n // It won't compile if Set.insert() is in an if statement :(\n // if amount as u120 > 0 {\n // create_note(balance, recipient, &mut note);\n // }\n}\n\n// Find some of the `owner`'s notes whose values add up to the `amount`.\n// Remove those notes.\n// If the value of the removed notes exceeds the requested `amount`, create a new note containing the excess value, so that exactly `amount` is removed.\n// Fail if the sum of the selected notes is less than the amount.\nfn decrement(\n balance: Set,\n amount: Field,\n owner: Field,\n) {\n let sum = decrement_by_at_most(balance, amount, owner);\n assert(sum == amount, \"Balance too low\");\n}\n\n// Similar to `decrement`, except that it doesn't fail if the decremented amount is less than max_amount.\n// The motivation behind this function is that there is an upper-bound on the number of notes a function may\n// read and nullify. The requested decrementation `amount` might be spread across too many of the `owner`'s\n// notes to 'fit' within this upper-bound, so we might have to remove an amount less than `amount`. A common\n// pattern is to repeatedly call this function across many function calls, until enough notes have been nullified to\n// equal `amount`.\n//\n// It returns the decremented amount, which should be less than or equal to max_amount.\nfn decrement_by_at_most(\n balance: Set,\n max_amount: Field,\n owner: Field,\n) -> Field {\n let options = create_note_getter_options_for_decreasing_balance(max_amount);\n let opt_notes = balance.get_notes(options);\n\n let mut decremented = 0;\n for i in 0..opt_notes.len() {\n if opt_notes[i].is_some() {\n decremented += destroy_note(balance, owner, opt_notes[i].unwrap_unchecked());\n }\n }\n\n // Add the change value back to the owner's balance.\n let mut change_value = 0;\n if decremented as u120 > max_amount as u120 {\n change_value = decremented - max_amount;\n decremented -= change_value;\n }\n increment(balance, change_value, owner);\n\n decremented\n}\n\nfn create_note(\n balance: Set,\n owner: Field,\n note: &mut ValueNote,\n) {\n // Insert the new note to the owner's set of notes.\n balance.insert(note);\n\n // Remove this if statement if we can wrap this create_note function in an if statement.\n if note.value != 0 {\n // Emit the newly created encrypted note preimages via oracle calls.\n // docs:start:encrypted\n let context = balance.context.private.unwrap();\n let application_contract_address = (*context).this_address();\n let note_storage_slot = balance.storage_slot;\n let encryption_pub_key = get_public_key(owner);\n let encrypted_data = (*note).serialise();\n\n emit_encrypted_log(\n context,\n application_contract_address,\n note_storage_slot,\n encryption_pub_key,\n encrypted_data,\n );\n // docs:end:encrypted\n }\n}\n\n// Removes the note from the owner's set of notes.\n// Returns the value of the destroyed note.\nfn destroy_note(\n balance: Set,\n owner: Field,\n note: ValueNote,\n) -> Field {\n // Ensure the note is actually owned by the owner (to prevent user from generating a valid proof while\n // spending someone else's notes).\n assert(note.owner == owner);\n\n balance.remove(note);\n \n note.value\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/value-note/src/utils" + "90": { + "source": "use dep::std::option::Option;\nuse dep::aztec::context::PrivateContext;\n// docs:start:encrypted_import\n\nuse dep::aztec::log::emit_encrypted_log;\n\n// docs:end:encrypted_import\nuse dep::aztec::note::note_getter_options::{NoteGetterOptions, SortOrder};\nuse dep::aztec::oracle::get_public_key::get_public_key;\nuse dep::aztec::state_vars::set::Set;\nuse crate::{\n filter::filter_notes_min_sum,\n value_note::{ValueNote, VALUE_NOTE_LEN},\n};\n\n// Sort the note values (0th field) in descending order.\n// Pick the fewest notes whose sum is equal to or greater than `amount`.\nfn create_note_getter_options_for_decreasing_balance(amount: Field) -> NoteGetterOptions {\n NoteGetterOptions::with_filter(filter_notes_min_sum, amount).sort(0, SortOrder.DESC)\n}\n\n// Creates a new note for the recipient.\n// Inserts it to the recipient's set of notes.\nfn increment(\n balance: Set,\n amount: Field,\n recipient: Field,\n) {\n let mut note = ValueNote::new(amount, recipient);\n create_note(balance, recipient, &mut note);\n\n // It won't compile if Set.insert() is in an if statement :(\n // if amount as u120 > 0 {\n // create_note(balance, recipient, &mut note);\n // }\n}\n\n// Find some of the `owner`'s notes whose values add up to the `amount`.\n// Remove those notes.\n// If the value of the removed notes exceeds the requested `amount`, create a new note containing the excess value, so that exactly `amount` is removed.\n// Fail if the sum of the selected notes is less than the amount.\nfn decrement(\n balance: Set,\n amount: Field,\n owner: Field,\n) {\n let sum = decrement_by_at_most(balance, amount, owner);\n assert(sum == amount, \"Balance too low\");\n}\n\n// Similar to `decrement`, except that it doesn't fail if the decremented amount is less than max_amount.\n// The motivation behind this function is that there is an upper-bound on the number of notes a function may\n// read and nullify. The requested decrementation `amount` might be spread across too many of the `owner`'s\n// notes to 'fit' within this upper-bound, so we might have to remove an amount less than `amount`. A common\n// pattern is to repeatedly call this function across many function calls, until enough notes have been nullified to\n// equal `amount`.\n//\n// It returns the decremented amount, which should be less than or equal to max_amount.\nfn decrement_by_at_most(\n balance: Set,\n max_amount: Field,\n owner: Field,\n) -> Field {\n let options = create_note_getter_options_for_decreasing_balance(max_amount);\n let opt_notes = balance.get_notes(options);\n\n let mut decremented = 0;\n for i in 0..opt_notes.len() {\n if opt_notes[i].is_some() {\n decremented += destroy_note(balance, owner, opt_notes[i].unwrap_unchecked());\n }\n }\n\n // Add the change value back to the owner's balance.\n let mut change_value = 0;\n if decremented as u120 > max_amount as u120 {\n change_value = decremented - max_amount;\n decremented -= change_value;\n }\n increment(balance, change_value, owner);\n\n decremented\n}\n\nfn create_note(\n balance: Set,\n owner: Field,\n note: &mut ValueNote,\n) {\n // Insert the new note to the owner's set of notes.\n balance.insert(note);\n\n // Remove this if statement if we can wrap this create_note function in an if statement.\n if note.value != 0 {\n // Emit the newly created encrypted note preimages via oracle calls.\n // docs:start:encrypted\n let context = balance.context.private.unwrap();\n let application_contract_address = (*context).this_address();\n let note_storage_slot = balance.storage_slot;\n let encryption_pub_key = get_public_key(owner);\n let encrypted_data = (*note).serialize();\n\n emit_encrypted_log(\n context,\n application_contract_address,\n note_storage_slot,\n encryption_pub_key,\n encrypted_data,\n );\n // docs:end:encrypted\n }\n}\n\n// Removes the note from the owner's set of notes.\n// Returns the value of the destroyed note.\nfn destroy_note(\n balance: Set,\n owner: Field,\n note: ValueNote,\n) -> Field {\n // Ensure the note is actually owned by the owner (to prevent user from generating a valid proof while\n // spending someone else's notes).\n assert(note.owner == owner);\n\n balance.remove(note);\n \n note.value\n}\n", + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/value-note/src/utils" }, - "89": { - "source": "use dep::aztec::note::{\n note_header::NoteHeader,\n note_interface::NoteInterface,\n utils::compute_note_hash_for_read_or_nullify,\n};\nuse dep::aztec::oracle::{\n rand::rand,\n get_secret_key::get_secret_key,\n};\n\nglobal VALUE_NOTE_LEN: Field = 3; // 3 plus a header.\n\n// docs:start:value-note-def\nstruct ValueNote {\n value: Field,\n owner: Field,\n randomness: Field,\n header: NoteHeader,\n}\n// docs:end:value-note-def\n\nimpl ValueNote {\n fn new(value: Field, owner: Field) -> Self {\n let randomness = rand();\n let header = NoteHeader::empty();\n ValueNote {\n value,\n owner,\n randomness,\n header,\n }\n }\n\n fn serialise(self) -> [Field; VALUE_NOTE_LEN] {\n [self.value, self.owner, self.randomness]\n }\n\n fn deserialise(preimage: [Field; VALUE_NOTE_LEN]) -> Self {\n ValueNote {\n value: preimage[0],\n owner: preimage[1],\n randomness: preimage[2],\n header: NoteHeader::empty(),\n }\n }\n\n fn compute_note_hash(self) -> Field {\n // TODO(#1205) Should use a non-zero generator index.\n dep::std::hash::pedersen([\n self.value, \n self.owner,\n self.randomness,\n ])[0]\n }\n\n // docs:start:nullifier\n\n fn compute_nullifier(self) -> Field {\n let note_hash_for_nullify = compute_note_hash_for_read_or_nullify(ValueNoteMethods, self);\n let secret = get_secret_key(self.owner);\n // TODO(#1205) Should use a non-zero generator index.\n dep::std::hash::pedersen([\n note_hash_for_nullify,\n secret.low,\n secret.high,\n ])[0]\n }\n\n // docs:end:nullifier\n\n fn set_header(&mut self, header: NoteHeader) {\n self.header = header;\n }\n}\n\nfn deserialise(preimage: [Field; VALUE_NOTE_LEN]) -> ValueNote {\n ValueNote::deserialise(preimage)\n}\n\nfn serialise(note: ValueNote) -> [Field; VALUE_NOTE_LEN] {\n note.serialise()\n}\n\nfn compute_note_hash(note: ValueNote) -> Field {\n note.compute_note_hash()\n}\n\nfn compute_nullifier(note: ValueNote) -> Field {\n note.compute_nullifier()\n}\n\nfn get_header(note: ValueNote) -> NoteHeader {\n note.header\n}\n\nfn set_header(note: &mut ValueNote, header: NoteHeader) {\n note.set_header(header)\n}\n\nglobal ValueNoteMethods = NoteInterface {\n deserialise,\n serialise,\n compute_note_hash,\n compute_nullifier,\n get_header,\n set_header,\n};\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/value-note/src/value_note" + "91": { + "source": "use dep::aztec::note::{\n note_header::NoteHeader,\n note_interface::NoteInterface,\n utils::compute_note_hash_for_read_or_nullify,\n};\nuse dep::aztec::oracle::{\n rand::rand,\n get_secret_key::get_secret_key,\n};\n\nglobal VALUE_NOTE_LEN: Field = 3; // 3 plus a header.\n\n// docs:start:value-note-def\nstruct ValueNote {\n value: Field,\n owner: Field,\n randomness: Field,\n header: NoteHeader,\n}\n// docs:end:value-note-def\n\nimpl ValueNote {\n fn new(value: Field, owner: Field) -> Self {\n let randomness = rand();\n let header = NoteHeader::empty();\n ValueNote {\n value,\n owner,\n randomness,\n header,\n }\n }\n\n fn serialize(self) -> [Field; VALUE_NOTE_LEN] {\n [self.value, self.owner, self.randomness]\n }\n\n fn deserialize(preimage: [Field; VALUE_NOTE_LEN]) -> Self {\n ValueNote {\n value: preimage[0],\n owner: preimage[1],\n randomness: preimage[2],\n header: NoteHeader::empty(),\n }\n }\n\n fn compute_note_hash(self) -> Field {\n // TODO(#1205) Should use a non-zero generator index.\n dep::std::hash::pedersen([\n self.value, \n self.owner,\n self.randomness,\n ])[0]\n }\n\n // docs:start:nullifier\n\n fn compute_nullifier(self) -> Field {\n let note_hash_for_nullify = compute_note_hash_for_read_or_nullify(ValueNoteMethods, self);\n let secret = get_secret_key(self.owner);\n // TODO(#1205) Should use a non-zero generator index.\n dep::std::hash::pedersen([\n note_hash_for_nullify,\n secret.low,\n secret.high,\n ])[0]\n }\n\n // docs:end:nullifier\n\n fn set_header(&mut self, header: NoteHeader) {\n self.header = header;\n }\n}\n\nfn deserialize(preimage: [Field; VALUE_NOTE_LEN]) -> ValueNote {\n ValueNote::deserialize(preimage)\n}\n\nfn serialize(note: ValueNote) -> [Field; VALUE_NOTE_LEN] {\n note.serialize()\n}\n\nfn compute_note_hash(note: ValueNote) -> Field {\n note.compute_note_hash()\n}\n\nfn compute_nullifier(note: ValueNote) -> Field {\n note.compute_nullifier()\n}\n\nfn get_header(note: ValueNote) -> NoteHeader {\n note.header\n}\n\nfn set_header(note: &mut ValueNote, header: NoteHeader) {\n note.set_header(header)\n}\n\nglobal ValueNoteMethods = NoteInterface {\n deserialize,\n serialize,\n compute_note_hash,\n compute_nullifier,\n get_header,\n set_header,\n};\n", + "path": "/mnt/user-data/leila/aztec-packages/yarn-project/aztec-nr/value-note/src/value_note" } } } diff --git a/yarn-project/boxes/private-token/src/contracts/src/main.nr b/yarn-project/boxes/private-token/src/contracts/src/main.nr index 4e885c06966..4b9b2402d53 100644 --- a/yarn-project/boxes/private-token/src/contracts/src/main.nr +++ b/yarn-project/boxes/private-token/src/contracts/src/main.nr @@ -95,7 +95,7 @@ contract PrivateToken { // Note 1: Needs to be defined by every contract producing logs. // Note 2: Having it in all the contracts gives us the ability to compute the note hash and nullifier differently for different kind of notes. unconstrained fn compute_note_hash_and_nullifier(contract_address: Field, nonce: Field, storage_slot: Field, preimage: [Field; VALUE_NOTE_LEN]) -> [Field; 4] { - let note_header = NoteHeader { contract_address, nonce, storage_slot }; + let note_header = NoteHeader::new(contract_address, nonce, storage_slot); note_utils::compute_note_hash_and_nullifier(ValueNoteMethods, note_header, preimage) } } \ No newline at end of file diff --git a/yarn-project/canary/package.json b/yarn-project/canary/package.json index 138d9b5b098..d621c6008e8 100644 --- a/yarn-project/canary/package.json +++ b/yarn-project/canary/package.json @@ -21,8 +21,8 @@ "rootDir": "./src" }, "dependencies": { - "@aztec/circuits.js": "workspace:^", "@aztec/aztec.js": "workspace:^", + "@aztec/circuits.js": "workspace:^", "@aztec/cli": "workspace:^", "@aztec/end-to-end": "workspace:^", "@aztec/l1-artifacts": "workspace:^", diff --git a/yarn-project/canary/src/uniswap_trade_on_l1_from_l2.test.ts b/yarn-project/canary/src/uniswap_trade_on_l1_from_l2.test.ts index 0b7b71414c1..8ae683ebfee 100644 --- a/yarn-project/canary/src/uniswap_trade_on_l1_from_l2.test.ts +++ b/yarn-project/canary/src/uniswap_trade_on_l1_from_l2.test.ts @@ -3,6 +3,8 @@ import { AztecAddress, EthAddress, Fr, + NotePreimage, + TxHash, TxStatus, computeMessageSecretHash, createDebugLogger, @@ -194,6 +196,7 @@ const consumeMessageOnAztecAndMintSecretly = async ( .send(); const consumptionReceipt = await consumptionTx.wait(); expect(consumptionReceipt.status).toBe(TxStatus.MINED); + return consumptionReceipt.txHash; }; const redeemShieldPrivatelyOnL2 = async ( @@ -201,7 +204,14 @@ const redeemShieldPrivatelyOnL2 = async ( to: AztecAddress, shieldAmount: bigint, secret: Fr, + secretHash: Fr, + txHash: TxHash, ) => { + // Add the note to the pxe. + const storageSlot = new Fr(5); + const preimage = new NotePreimage([new Fr(shieldAmount), secretHash]); + await pxe.addNote(to, l2Contract.address, storageSlot, preimage, txHash); + logger('Spending commitment in private call'); const privateTx = l2Contract.methods.redeem_shield(to, shieldAmount, secret).send(); const privateReceipt = await privateTx.wait(); @@ -300,7 +310,7 @@ describe('uniswap_trade_on_l1_from_l2', () => { // 3. Claim WETH on L2 logger('Minting weth on L2'); - await consumeMessageOnAztecAndMintSecretly( + const redeemingWethTxHash = await consumeMessageOnAztecAndMintSecretly( wethL2Bridge, wethAmountToBridge, secretHashForRedeemingWeth, @@ -308,7 +318,14 @@ describe('uniswap_trade_on_l1_from_l2', () => { messageKey, secretForMintingWeth, ); - await redeemShieldPrivatelyOnL2(wethL2Contract, ownerAddress, wethAmountToBridge, secretForRedeemingWeth); + await redeemShieldPrivatelyOnL2( + wethL2Contract, + ownerAddress, + wethAmountToBridge, + secretForRedeemingWeth, + secretHashForRedeemingWeth, + redeemingWethTxHash, + ); await expectPrivateBalanceOnL2(ownerAddress, wethAmountToBridge + BigInt(ownerInitialBalance), wethL2Contract); // Store balances @@ -396,7 +413,7 @@ describe('uniswap_trade_on_l1_from_l2', () => { // 7. claim dai on L2 logger('Consuming messages to mint dai on L2'); - await consumeMessageOnAztecAndMintSecretly( + const redeemingDaiTxHash = await consumeMessageOnAztecAndMintSecretly( daiL2Bridge, daiAmountToBridge, secretHashForRedeemingDai, @@ -404,7 +421,14 @@ describe('uniswap_trade_on_l1_from_l2', () => { depositDaiMessageKey, secretForDepositingSwappedDai, ); - await redeemShieldPrivatelyOnL2(daiL2Contract, ownerAddress, daiAmountToBridge, secretForRedeemingDai); + await redeemShieldPrivatelyOnL2( + daiL2Contract, + ownerAddress, + daiAmountToBridge, + secretForRedeemingDai, + secretHashForRedeemingDai, + redeemingDaiTxHash, + ); await expectPrivateBalanceOnL2(ownerAddress, daiL2BalanceBeforeSwap + daiAmountToBridge, daiL2Contract); const wethL2BalanceAfterSwap = await getL2PrivateBalanceOf(ownerAddress, wethL2Contract); diff --git a/yarn-project/cli/src/index.ts b/yarn-project/cli/src/index.ts index 55dd7417706..962acb0aa61 100644 --- a/yarn-project/cli/src/index.ts +++ b/yarn-project/cli/src/index.ts @@ -3,6 +3,7 @@ import { ContractDeployer, Fr, GrumpkinScalar, + NotePreimage, generatePublicKey, getSchnorrAccount, isContractDeployed, @@ -30,6 +31,8 @@ import { getExampleContractArtifacts, getTxSender, parseAztecAddress, + parseField, + parseFields, parsePartialAddress, parsePrivateKey, parsePublicKey, @@ -440,6 +443,21 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command { log('\nView result: ', result, '\n'); }); + program + .command('add-note') + .description('Adds a note to the database in the PXE.') + .argument('
', 'The Aztec address of the note owner.', parseAztecAddress) + .argument('', 'Aztec address of the contract.', parseAztecAddress) + .argument('', 'The storage slot of the note.', parseField) + .argument('', 'The tx hash of the tx containing the note.', parseTxHash) + .requiredOption('-p, --preimage [notePreimage...]', 'Note preimage.', []) + .addOption(pxeOption) + .action(async (address, contractAddress, storageSlot, txHash, options) => { + const preimage = new NotePreimage(parseFields(options.preimage)); + const client = await createCompatibleClient(options.rpcUrl, debugLogger); + await client.addNote(address, contractAddress, storageSlot, preimage, txHash); + }); + // Helper for users to decode hex strings into structs if needed. program .command('parse-parameter-struct') diff --git a/yarn-project/cli/src/utils.ts b/yarn-project/cli/src/utils.ts index 2d1db6b43c2..8e6f527f9ca 100644 --- a/yarn-project/cli/src/utils.ts +++ b/yarn-project/cli/src/utils.ts @@ -267,3 +267,44 @@ export function parsePrivateKey(privateKey: string): GrumpkinScalar { throw new InvalidArgumentError(`Invalid private key: ${privateKey}`); } } + +/** + * Parses a field from a string. Throws InvalidArgumentError if the string is not a valid field value. + * @param field - A string representing the field. + * @returns A field. + */ +export function parseField(field: string): Fr { + try { + const isHex = field.startsWith('0x') || field.match(new RegExp(`^[0-9a-f]{${Fr.SIZE_IN_BYTES * 2}}$`, 'i')); + if (isHex) { + return Fr.fromString(field); + } + + if (['true', 'false'].includes(field)) { + return new Fr(field === 'true'); + } + + const isNumber = +field || field === '0'; + if (isNumber) { + return new Fr(BigInt(field)); + } + + const isBigInt = field.endsWith('n'); + if (isBigInt) { + return new Fr(BigInt(field.replace(/n$/, ''))); + } + + return new Fr(BigInt(field)); + } catch (err) { + throw new InvalidArgumentError(`Invalid field: ${field}`); + } +} + +/** + * Parses an array of strings to Frs. + * @param fields - An array of strings representing the fields. + * @returns An array of Frs. + */ +export function parseFields(fields: string[]): Fr[] { + return fields.map(parseField); +} diff --git a/yarn-project/end-to-end/src/canary/browser.ts b/yarn-project/end-to-end/src/canary/browser.ts index 2053fbfab21..bf145149e99 100644 --- a/yarn-project/end-to-end/src/canary/browser.ts +++ b/yarn-project/end-to-end/src/canary/browser.ts @@ -162,6 +162,7 @@ export const browserTestSuite = (setup: () => Server, pageLogger: AztecJs.DebugL getUnsafeSchnorrAccount, Contract, Fr, + NotePreimage, computeMessageSecretHash, getSandboxAccountsWallets, } = window.AztecJs; @@ -174,17 +175,23 @@ export const browserTestSuite = (setup: () => Server, pageLogger: AztecJs.DebugL accounts = await pxe.getRegisteredAccounts(); } const [owner] = await getSandboxAccountsWallets(pxe); + const ownerAddress = owner.getAddress(); const tx = new DeployMethod(accounts[0].publicKey, pxe, TokenContractAbi).send(); await tx.wait(); const receipt = await tx.getReceipt(); console.log(`Contract Deployed: ${receipt.contractAddress}`); const token = await Contract.at(receipt.contractAddress!, TokenContractAbi, owner); - await token.methods._initialize(owner.getAddress()).send().wait(); + await token.methods._initialize(ownerAddress).send().wait(); const secret = Fr.random(); const secretHash = await computeMessageSecretHash(secret); - await token.methods.mint_private(initialBalance, secretHash).send().wait(); - await token.methods.redeem_shield(owner.getAddress(), initialBalance, secret).send().wait(); + const mintPrivateReceipt = await token.methods.mint_private(initialBalance, secretHash).send().wait(); + + const storageSlot = new Fr(5); + const preimage = new NotePreimage([new Fr(initialBalance), secretHash]); + await pxe.addNote(ownerAddress, token.address, storageSlot, preimage, mintPrivateReceipt.txHash); + + await token.methods.redeem_shield(ownerAddress, initialBalance, secret).send().wait(); return receipt.txHash.toString(); }, diff --git a/yarn-project/end-to-end/src/canary/cli.ts b/yarn-project/end-to-end/src/canary/cli.ts index cffc82ff952..1974ee6573e 100644 --- a/yarn-project/end-to-end/src/canary/cli.ts +++ b/yarn-project/end-to-end/src/canary/cli.ts @@ -143,6 +143,15 @@ export const cliTestSuite = ( await run( `send mint_private --args ${INITIAL_BALANCE} ${secretHash} --contract-abi TokenContractAbi --contract-address ${contractAddress.toString()} --private-key ${privKey}`, ); + + debug('Add note to the PXE.'); + const txHashes = findMultipleInLogs(/Transaction Hash: ([0-9a-f]{64})/i); + const mintPrivateTxHash = txHashes[txHashes.length - 1][1]; + await run( + `add-note ${ownerAddress} ${contractAddress} 5 ${mintPrivateTxHash} --preimage ${INITIAL_BALANCE} ${secretHash}`, + ); + + debug('Redeem tokens.'); await run( `send redeem_shield --args ${ownerAddress} ${INITIAL_BALANCE} ${secret} --contract-abi TokenContractAbi --contract-address ${contractAddress.toString()} --private-key ${privKey}`, ); diff --git a/yarn-project/end-to-end/src/e2e_2_pxes.test.ts b/yarn-project/end-to-end/src/e2e_2_pxes.test.ts index 9a2a5256c33..f19ee8aebca 100644 --- a/yarn-project/end-to-end/src/e2e_2_pxes.test.ts +++ b/yarn-project/end-to-end/src/e2e_2_pxes.test.ts @@ -1,5 +1,5 @@ import { AztecNodeService } from '@aztec/aztec-node'; -import { AztecAddress, Wallet, computeMessageSecretHash } from '@aztec/aztec.js'; +import { AztecAddress, NotePreimage, Wallet, computeMessageSecretHash } from '@aztec/aztec.js'; import { DebugLogger } from '@aztec/foundation/log'; import { retryUntil } from '@aztec/foundation/retry'; import { toBigInt } from '@aztec/foundation/serialize'; @@ -83,13 +83,13 @@ describe('e2e_2_pxes', () => { expect(balance).toBe(expectedBalance); }; - const deployTokenContract = async (initialAdminBalance: bigint, admin: AztecAddress) => { + const deployTokenContract = async (initialAdminBalance: bigint, admin: AztecAddress, pxe: PXE) => { logger(`Deploying Token contract...`); const contract = await TokenContract.deploy(walletA).send().deployed(); expect((await contract.methods._initialize(admin).send().wait()).status).toBe(TxStatus.MINED); if (initialAdminBalance > 0n) { - await mintTokens(contract, admin, initialAdminBalance); + await mintTokens(contract, admin, initialAdminBalance, pxe); } logger('L2 contract deployed'); @@ -97,11 +97,17 @@ describe('e2e_2_pxes', () => { return contract.completeAddress; }; - const mintTokens = async (contract: TokenContract, recipient: AztecAddress, balance: bigint) => { + const mintTokens = async (contract: TokenContract, recipient: AztecAddress, balance: bigint, pxe: PXE) => { const secret = Fr.random(); const secretHash = await computeMessageSecretHash(secret); - expect((await contract.methods.mint_private(balance, secretHash).send().wait()).status).toEqual(TxStatus.MINED); + const receipt = await contract.methods.mint_private(balance, secretHash).send().wait(); + expect(receipt.status).toEqual(TxStatus.MINED); + + const storageSlot = new Fr(5); + const preimage = new NotePreimage([new Fr(balance), secretHash]); + await pxe.addNote(recipient, contract.address, storageSlot, preimage, receipt.txHash); + expect((await contract.methods.redeem_shield(recipient, balance, secret).send().wait()).status).toEqual( TxStatus.MINED, ); @@ -112,7 +118,7 @@ describe('e2e_2_pxes', () => { const transferAmount1 = 654n; const transferAmount2 = 323n; - const completeTokenAddress = await deployTokenContract(initialBalance, userA.address); + const completeTokenAddress = await deployTokenContract(initialBalance, userA.address, pxeA); const tokenAddress = completeTokenAddress.address; // Add account B to wallet A @@ -207,7 +213,7 @@ describe('e2e_2_pxes', () => { const userABalance = 100n; const userBBalance = 150n; - const completeTokenAddress = await deployTokenContract(userABalance, userA.address); + const completeTokenAddress = await deployTokenContract(userABalance, userA.address, pxeA); const contractWithWalletA = await TokenContract.at(completeTokenAddress.address, walletA); // Add account B to wallet A @@ -225,7 +231,7 @@ describe('e2e_2_pxes', () => { ]); // Mint tokens to user B - await mintTokens(contractWithWalletA, userB.address, userBBalance); + await mintTokens(contractWithWalletA, userB.address, userBBalance, pxeA); // Check that user A balance is 100 on server A await expectTokenBalance(walletA, completeTokenAddress.address, userA.address, userABalance); diff --git a/yarn-project/end-to-end/src/e2e_cross_chain_messaging.test.ts b/yarn-project/end-to-end/src/e2e_cross_chain_messaging.test.ts index c9eb2d5ae42..7b3531c1695 100644 --- a/yarn-project/end-to-end/src/e2e_cross_chain_messaging.test.ts +++ b/yarn-project/end-to-end/src/e2e_cross_chain_messaging.test.ts @@ -186,6 +186,11 @@ describe('e2e_cross_chain_messaging', () => { expect(consumptionReceipt.status).toBe(TxStatus.MINED); // Now user1 can claim the notes that user2 minted on their behalf. + await crossChainTestHarness.addPendingShieldNoteToPXE( + bridgeAmount, + secretHashForRedeemingMintedNotes, + consumptionReceipt.txHash, + ); await crossChainTestHarness.redeemShieldPrivatelyOnL2(bridgeAmount, secretForRedeemingMintedNotes); await crossChainTestHarness.expectPrivateBalanceOnL2(ownerAddress, bridgeAmount); }, 50_000); diff --git a/yarn-project/end-to-end/src/e2e_escrow_contract.test.ts b/yarn-project/end-to-end/src/e2e_escrow_contract.test.ts index 075df4b3ef1..ad0315c5fa0 100644 --- a/yarn-project/end-to-end/src/e2e_escrow_contract.test.ts +++ b/yarn-project/end-to-end/src/e2e_escrow_contract.test.ts @@ -1,4 +1,11 @@ -import { AccountWallet, AztecAddress, BatchCall, computeMessageSecretHash, generatePublicKey } from '@aztec/aztec.js'; +import { + AccountWallet, + AztecAddress, + BatchCall, + NotePreimage, + computeMessageSecretHash, + generatePublicKey, +} from '@aztec/aztec.js'; import { CompleteAddress, Fr, GrumpkinPrivateKey, GrumpkinScalar, getContractDeploymentInfo } from '@aztec/circuits.js'; import { DebugLogger } from '@aztec/foundation/log'; import { EscrowContractAbi } from '@aztec/noir-contracts/artifacts'; @@ -8,6 +15,7 @@ import { PXE, PublicKey, TxStatus } from '@aztec/types'; import { setup } from './fixtures/utils.js'; describe('e2e_escrow_contract', () => { + const pendingShieldsStorageSlot = new Fr(5); let pxe: PXE; let wallet: AccountWallet; let recipientWallet: AccountWallet; @@ -53,13 +61,19 @@ describe('e2e_escrow_contract', () => { expect((await token.methods._initialize(owner).send().wait()).status).toBe(TxStatus.MINED); + const mintAmount = 100n; const secret = Fr.random(); const secretHash = await computeMessageSecretHash(secret); - expect((await token.methods.mint_private(100n, secretHash).send().wait()).status).toEqual(TxStatus.MINED); - expect((await token.methods.redeem_shield(escrowContract.address, 100n, secret).send().wait()).status).toEqual( - TxStatus.MINED, - ); + const receipt = await token.methods.mint_private(mintAmount, secretHash).send().wait(); + expect(receipt.status).toEqual(TxStatus.MINED); + + const preimage = new NotePreimage([new Fr(mintAmount), secretHash]); + await pxe.addNote(escrowContract.address, token.address, pendingShieldsStorageSlot, preimage, receipt.txHash); + + expect( + (await token.methods.redeem_shield(escrowContract.address, mintAmount, secret).send().wait()).status, + ).toEqual(TxStatus.MINED); logger(`Token contract deployed at ${token.address}`); }, 100_000); @@ -93,11 +107,17 @@ describe('e2e_escrow_contract', () => { it('moves funds using multiple keys on the same tx (#1010)', async () => { logger(`Minting funds in token contract to ${owner}`); + const mintAmount = 50n; const secret = Fr.random(); const secretHash = await computeMessageSecretHash(secret); - expect((await token.methods.mint_private(50n, secretHash).send().wait()).status).toEqual(TxStatus.MINED); - expect((await token.methods.redeem_shield(owner, 50n, secret).send().wait()).status).toEqual(TxStatus.MINED); + const receipt = await token.methods.mint_private(mintAmount, secretHash).send().wait(); + expect(receipt.status).toEqual(TxStatus.MINED); + + const preimage = new NotePreimage([new Fr(mintAmount), secretHash]); + await pxe.addNote(owner, token.address, pendingShieldsStorageSlot, preimage, receipt.txHash); + + expect((await token.methods.redeem_shield(owner, mintAmount, secret).send().wait()).status).toEqual(TxStatus.MINED); await expectBalance(owner, 50n); diff --git a/yarn-project/end-to-end/src/e2e_lending_contract.test.ts b/yarn-project/end-to-end/src/e2e_lending_contract.test.ts index 4f8dfe54b8e..9ba8808215d 100644 --- a/yarn-project/end-to-end/src/e2e_lending_contract.test.ts +++ b/yarn-project/end-to-end/src/e2e_lending_contract.test.ts @@ -3,7 +3,7 @@ import { CircuitsWasm, CompleteAddress, FunctionSelector, GeneratorIndex } from import { pedersenPlookupCompressWithHashIndex } from '@aztec/circuits.js/barretenberg'; import { DebugLogger } from '@aztec/foundation/log'; import { LendingContract, PriceFeedContract, TokenContract } from '@aztec/noir-contracts/types'; -import { TxStatus } from '@aztec/types'; +import { NotePreimage, TxStatus } from '@aztec/types'; import { jest } from '@jest/globals'; @@ -121,8 +121,13 @@ describe('e2e_lending_contract', () => { const a = asset.methods.mint_public(lendingAccount.address, mintAmount).send(); const b = asset.methods.mint_private(mintAmount, secretHash).send(); - await Promise.all([a, b].map(waitForSuccess)); + + const storageSlot = new Fr(5); + const preimage = new NotePreimage([new Fr(mintAmount), secretHash]); + const txHash = await b.getTxHash(); + await wallet.addNote(accounts[0].address, asset.address, storageSlot, preimage, txHash); + await waitForSuccess(asset.methods.redeem_shield(lendingAccount.address, mintAmount, secret).send()); } } diff --git a/yarn-project/end-to-end/src/e2e_multiple_accounts_1_enc_key.test.ts b/yarn-project/end-to-end/src/e2e_multiple_accounts_1_enc_key.test.ts index 651552a7d2a..b1069faedc0 100644 --- a/yarn-project/end-to-end/src/e2e_multiple_accounts_1_enc_key.test.ts +++ b/yarn-project/end-to-end/src/e2e_multiple_accounts_1_enc_key.test.ts @@ -1,5 +1,12 @@ import { AztecNodeService } from '@aztec/aztec-node'; -import { AztecAddress, Wallet, computeMessageSecretHash, generatePublicKey, getSchnorrAccount } from '@aztec/aztec.js'; +import { + AztecAddress, + NotePreimage, + Wallet, + computeMessageSecretHash, + generatePublicKey, + getSchnorrAccount, +} from '@aztec/aztec.js'; import { Fr, GrumpkinScalar } from '@aztec/circuits.js'; import { DebugLogger } from '@aztec/foundation/log'; import { TokenContract } from '@aztec/noir-contracts/types'; @@ -52,7 +59,13 @@ describe('e2e_multiple_accounts_1_enc_key', () => { const secret = Fr.random(); const secretHash = await computeMessageSecretHash(secret); - expect((await token.methods.mint_private(initialBalance, secretHash).send().wait()).status).toEqual(TxStatus.MINED); + const receipt = await token.methods.mint_private(initialBalance, secretHash).send().wait(); + expect(receipt.status).toEqual(TxStatus.MINED); + + const storageSlot = new Fr(5); + const preimage = new NotePreimage([new Fr(initialBalance), secretHash]); + await pxe.addNote(accounts[0], token.address, storageSlot, preimage, receipt.txHash); + expect((await token.methods.redeem_shield(accounts[0], initialBalance, secret).send().wait()).status).toEqual( TxStatus.MINED, ); diff --git a/yarn-project/end-to-end/src/e2e_private_airdrop.test.ts b/yarn-project/end-to-end/src/e2e_private_airdrop.test.ts index c1db1d6e60f..b88428e81c0 100644 --- a/yarn-project/end-to-end/src/e2e_private_airdrop.test.ts +++ b/yarn-project/end-to-end/src/e2e_private_airdrop.test.ts @@ -1,8 +1,7 @@ -import { CompleteAddress, TxHash, Wallet } from '@aztec/aztec.js'; +import { CompleteAddress, NotePreimage, TxHash, Wallet } from '@aztec/aztec.js'; import { Fr, MAX_NEW_COMMITMENTS_PER_CALL } from '@aztec/circuits.js'; import { DebugLogger } from '@aztec/foundation/log'; import { PrivateTokenAirdropContract } from '@aztec/noir-contracts/types'; -import { NotePreimage } from '@aztec/types'; import { setup } from './fixtures/utils.js'; @@ -71,7 +70,10 @@ describe('private airdrop', () => { expect(nonces.length).toBe(numNonces); expect(nonces[nonceIndex]).not.toEqual(Fr.ZERO); - return contract.methods.claim(claim.amount, claim.secret, account, nonces[nonceIndex]).send().wait(); + const nonce = nonces[nonceIndex]; + await wallet.addNote(account, contract.address, claimsStorageSlot, claim.preimage, txHash, nonce); + + return contract.methods.claim(claim.amount, claim.secret).send().wait(); }; it('should create claim notes for any accounts to claim', async () => { diff --git a/yarn-project/end-to-end/src/e2e_sandbox_example.test.ts b/yarn-project/end-to-end/src/e2e_sandbox_example.test.ts index d08674bb55c..c3ddec3f42a 100644 --- a/yarn-project/end-to-end/src/e2e_sandbox_example.test.ts +++ b/yarn-project/end-to-end/src/e2e_sandbox_example.test.ts @@ -1,6 +1,7 @@ // docs:start:imports import { Fr, + NotePreimage, PXE, computeMessageSecretHash, createDebugLogger, @@ -69,7 +70,12 @@ describe('e2e_sandbox_example', () => { const secret = Fr.random(); const secretHash = await computeMessageSecretHash(secret); - await tokenContractAlice.methods.mint_private(initialSupply, secretHash).send().wait(); + const receipt = await tokenContractAlice.methods.mint_private(initialSupply, secretHash).send().wait(); + + const pendingShieldsStorageSlot = new Fr(5); // The storage slot of `pending_shields` is 5. + const preimage = new NotePreimage([new Fr(initialSupply), secretHash]); + await pxe.addNote(alice, contract.address, pendingShieldsStorageSlot, preimage, receipt.txHash); + await tokenContractAlice.methods.redeem_shield(alice, initialSupply, secret).send().wait(); // docs:end:Deployment @@ -120,7 +126,11 @@ describe('e2e_sandbox_example', () => { // Now mint some further funds for Bob const mintQuantity = 10_000n; logger(`Minting ${mintQuantity} tokens to Bob...`); - await tokenContractBob.methods.mint_private(mintQuantity, secretHash).send().wait(); + const mintPrivateReceipt = await tokenContractBob.methods.mint_private(mintQuantity, secretHash).send().wait(); + + const bobPendingShield = new NotePreimage([new Fr(mintQuantity), secretHash]); + await pxe.addNote(bob, contract.address, pendingShieldsStorageSlot, bobPendingShield, mintPrivateReceipt.txHash); + await tokenContractBob.methods.redeem_shield(bob, mintQuantity, secret).send().wait(); // Check the new balances diff --git a/yarn-project/end-to-end/src/e2e_token_contract.test.ts b/yarn-project/end-to-end/src/e2e_token_contract.test.ts index a910d8bd6e4..c0d6a38ef0e 100644 --- a/yarn-project/end-to-end/src/e2e_token_contract.test.ts +++ b/yarn-project/end-to-end/src/e2e_token_contract.test.ts @@ -1,9 +1,8 @@ -import { AccountWallet, computeMessageSecretHash } from '@aztec/aztec.js'; +import { AccountWallet, NotePreimage, TxHash, TxStatus, computeMessageSecretHash } from '@aztec/aztec.js'; import { CircuitsWasm, CompleteAddress, Fr, FunctionSelector, GeneratorIndex } from '@aztec/circuits.js'; import { pedersenPlookupCompressWithHashIndex } from '@aztec/circuits.js/barretenberg'; import { DebugLogger } from '@aztec/foundation/log'; import { TokenContract } from '@aztec/noir-contracts/types'; -import { TxStatus } from '@aztec/types'; import { jest } from '@jest/globals'; @@ -32,6 +31,12 @@ describe('e2e_token_contract', () => { let tokenSim: TokenSimulator; + const addPendingShieldNoteToPXE = async (accountIndex: number, amount: bigint, secretHash: Fr, txHash: TxHash) => { + const storageSlot = new Fr(5); // The storage slot of `pending_shields` is 5. + const preimage = new NotePreimage([new Fr(amount), secretHash]); + await wallets[accountIndex].addNote(accounts[0].address, asset.address, storageSlot, preimage, txHash); + }; + beforeAll(async () => { ({ teardown, logger, wallets, accounts } = await setup(3)); @@ -148,6 +153,7 @@ describe('e2e_token_contract', () => { const secret = Fr.random(); const amount = 10000n; let secretHash: Fr; + let txHash: TxHash; beforeAll(async () => { secretHash = await computeMessageSecretHash(secret); @@ -159,9 +165,11 @@ describe('e2e_token_contract', () => { const receipt = await tx.wait(); expect(receipt.status).toBe(TxStatus.MINED); tokenSim.mintPrivate(amount); + txHash = receipt.txHash; }); it('redeem as recipient', async () => { + await addPendingShieldNoteToPXE(0, amount, secretHash, txHash); const txClaim = asset.methods.redeem_shield(accounts[0].address, amount, secret).send(); const receiptClaim = await txClaim.wait(); expect(receiptClaim.status).toBe(TxStatus.MINED); @@ -171,10 +179,12 @@ describe('e2e_token_contract', () => { describe('failure cases', () => { it('try to redeem as recipient (double-spend) [REVERTS]', async () => { - const txClaim = asset.methods.redeem_shield(accounts[0].address, amount, secret).send(); - await txClaim.isMined(); - const receipt = await txClaim.getReceipt(); - expect(receipt.status).toBe(TxStatus.DROPPED); + await expect(addPendingShieldNoteToPXE(0, amount, secretHash, txHash)).rejects.toThrowError( + 'The note has been destroyed.', + ); + await expect( + asset.methods.redeem_shield(accounts[0].address, amount, secret).simulate(), + ).rejects.toThrowError('Can only remove a note that has been read from the set.'); }); it('mint_private as non-minter', async () => { @@ -596,17 +606,12 @@ describe('e2e_token_contract', () => { await tokenSim.check(); // Redeem it + await addPendingShieldNoteToPXE(0, amount, secretHash, receipt.txHash); const txClaim = asset.methods.redeem_shield(accounts[0].address, amount, secret).send(); const receiptClaim = await txClaim.wait(); expect(receiptClaim.status).toBe(TxStatus.MINED); tokenSim.redeemShield(accounts[0].address, amount); - - // Check that claiming again will hit a double-spend and fail due to pending note already consumed. - const txClaimDoubleSpend = asset.methods.redeem_shield(accounts[0].address, amount, secret).send(); - await txClaimDoubleSpend.isMined(); - const receiptDoubleSpend = await txClaimDoubleSpend.getReceipt(); - expect(receiptDoubleSpend.status).toBe(TxStatus.DROPPED); }); it('on behalf of other', async () => { @@ -636,17 +641,12 @@ describe('e2e_token_contract', () => { expect(receiptReplay.status).toBe(TxStatus.DROPPED); // Redeem it + await addPendingShieldNoteToPXE(0, amount, secretHash, receipt.txHash); const txClaim = asset.methods.redeem_shield(accounts[0].address, amount, secret).send(); const receiptClaim = await txClaim.wait(); expect(receiptClaim.status).toBe(TxStatus.MINED); tokenSim.redeemShield(accounts[0].address, amount); - - // Check that claiming again will hit a double-spend and fail due to pending note already consumed. - const txClaimDoubleSpend = asset.methods.redeem_shield(accounts[0].address, amount, secret).send(); - await txClaimDoubleSpend.isMined(); - const receiptDoubleSpend = await txClaimDoubleSpend.getReceipt(); - expect(receiptDoubleSpend.status).toBe(TxStatus.DROPPED); }); describe('failure cases', () => { diff --git a/yarn-project/end-to-end/src/fixtures/cross_chain_test_harness.ts b/yarn-project/end-to-end/src/fixtures/cross_chain_test_harness.ts index 4eba012fa93..59aa1735331 100644 --- a/yarn-project/end-to-end/src/fixtures/cross_chain_test_harness.ts +++ b/yarn-project/end-to-end/src/fixtures/cross_chain_test_harness.ts @@ -1,5 +1,5 @@ import { AztecNodeService } from '@aztec/aztec-node'; -import { CheatCodes, Wallet, computeMessageSecretHash } from '@aztec/aztec.js'; +import { CheatCodes, TxHash, Wallet, computeMessageSecretHash } from '@aztec/aztec.js'; import { AztecAddress, CompleteAddress, EthAddress, Fr, PublicKey } from '@aztec/circuits.js'; import { DeployL1Contracts } from '@aztec/ethereum'; import { toBufferBE } from '@aztec/foundation/bigint-buffer'; @@ -8,7 +8,7 @@ import { DebugLogger } from '@aztec/foundation/log'; import { OutboxAbi } from '@aztec/l1-artifacts'; import { TokenBridgeContract, TokenContract } from '@aztec/noir-contracts/types'; import { PXEService } from '@aztec/pxe'; -import { PXE, TxStatus } from '@aztec/types'; +import { NotePreimage, PXE, TxStatus } from '@aztec/types'; import { Chain, HttpTransport, PublicClient, getContract } from 'viem'; @@ -195,6 +195,7 @@ export class CrossChainTestHarness { } async mintTokensPublicOnL2(amount: bigint) { + this.logger('Minting tokens on L2 publicly'); const tx = this.l2Token.methods.mint_public(this.ownerAddress, amount).send(); const receipt = await tx.wait(); expect(receipt.status).toBe(TxStatus.MINED); @@ -226,6 +227,8 @@ export class CrossChainTestHarness { .send(); const consumptionReceipt = await consumptionTx.wait(); expect(consumptionReceipt.status).toBe(TxStatus.MINED); + + await this.addPendingShieldNoteToPXE(bridgeAmount, secretHashForRedeemingMintedNotes, consumptionReceipt.txHash); } async consumeMessageOnAztecAndMintPublicly(bridgeAmount: bigint, messageKey: Fr, secret: Fr) { @@ -316,9 +319,19 @@ export class CrossChainTestHarness { } async shieldFundsOnL2(shieldAmount: bigint, secretHash: Fr) { + this.logger('Shielding funds on L2'); const shieldTx = this.l2Token.methods.shield(this.ownerAddress, shieldAmount, secretHash, 0).send(); const shieldReceipt = await shieldTx.wait(); expect(shieldReceipt.status).toBe(TxStatus.MINED); + + await this.addPendingShieldNoteToPXE(shieldAmount, secretHash, shieldReceipt.txHash); + } + + async addPendingShieldNoteToPXE(shieldAmount: bigint, secretHash: Fr, txHash: TxHash) { + this.logger('Adding note to PXE'); + const storageSlot = new Fr(5); + const preimage = new NotePreimage([new Fr(shieldAmount), secretHash]); + await this.pxeService.addNote(this.ownerAddress, this.l2Token.address, storageSlot, preimage, txHash); } async redeemShieldPrivatelyOnL2(shieldAmount: bigint, secret: Fr) { diff --git a/yarn-project/end-to-end/src/guides/dapp_testing.test.ts b/yarn-project/end-to-end/src/guides/dapp_testing.test.ts index 0c9aa989a23..710cea3bf33 100644 --- a/yarn-project/end-to-end/src/guides/dapp_testing.test.ts +++ b/yarn-project/end-to-end/src/guides/dapp_testing.test.ts @@ -4,6 +4,7 @@ import { CheatCodes, Fr, L2BlockL2Logs, + NotePreimage, PXE, computeMessageSecretHash, createAccount, @@ -40,12 +41,20 @@ describe('guides/dapp/testing', () => { // docs:end:stop-in-proc-sandbox it('increases recipient funds on mint', async () => { - expect(await token.methods.balance_of_private(recipient.getAddress()).view()).toEqual(0n); + const recipientAddress = recipient.getAddress(); + expect(await token.methods.balance_of_private(recipientAddress).view()).toEqual(0n); + + const mintAmount = 20n; const secret = Fr.random(); const secretHash = await computeMessageSecretHash(secret); - await token.methods.mint_private(20n, secretHash).send().wait(); - await token.methods.redeem_shield(recipient.getAddress(), 20n, secret).send().wait(); - expect(await token.methods.balance_of_private(recipient.getAddress()).view()).toEqual(20n); + const receipt = await token.methods.mint_private(mintAmount, secretHash).send().wait(); + + const storageSlot = new Fr(5); + const preimage = new NotePreimage([new Fr(mintAmount), secretHash]); + await pxe.addNote(recipientAddress, token.address, storageSlot, preimage, receipt.txHash); + + await token.methods.redeem_shield(recipientAddress, mintAmount, secret).send().wait(); + expect(await token.methods.balance_of_private(recipientAddress).view()).toEqual(20n); }, 30_000); }); }); @@ -72,12 +81,20 @@ describe('guides/dapp/testing', () => { }, 30_000); it('increases recipient funds on mint', async () => { - expect(await token.methods.balance_of_private(recipient.getAddress()).view()).toEqual(0n); + const recipientAddress = recipient.getAddress(); + expect(await token.methods.balance_of_private(recipientAddress).view()).toEqual(0n); + + const mintAmount = 20n; const secret = Fr.random(); const secretHash = await computeMessageSecretHash(secret); - await token.methods.mint_private(20n, secretHash).send().wait(); - await token.methods.redeem_shield(recipient.getAddress(), 20n, secret).send().wait(); - expect(await token.methods.balance_of_private(recipient.getAddress()).view()).toEqual(20n); + const receipt = await token.methods.mint_private(mintAmount, secretHash).send().wait(); + + const storageSlot = new Fr(5); // The storage slot of `pending_shields` is 5. + const preimage = new NotePreimage([new Fr(mintAmount), secretHash]); + await pxe.addNote(recipientAddress, token.address, storageSlot, preimage, receipt.txHash); + + await token.methods.redeem_shield(recipientAddress, mintAmount, secret).send().wait(); + expect(await token.methods.balance_of_private(recipientAddress).view()).toEqual(20n); }, 30_000); }); // docs:end:sandbox-example @@ -99,11 +116,18 @@ describe('guides/dapp/testing', () => { it('increases recipient funds on mint', async () => { expect(await token.methods.balance_of_private(recipient.getAddress()).view()).toEqual(0n); + const recipientAddress = recipient.getAddress(); + const mintAmount = 20n; const secret = Fr.random(); const secretHash = await computeMessageSecretHash(secret); - await token.methods.mint_private(20n, secretHash).send().wait(); - await token.methods.redeem_shield(recipient.getAddress(), 20n, secret).send().wait(); - expect(await token.methods.balance_of_private(recipient.getAddress()).view()).toEqual(20n); + const receipt = await token.methods.mint_private(mintAmount, secretHash).send().wait(); + + const storageSlot = new Fr(5); + const preimage = new NotePreimage([new Fr(mintAmount), secretHash]); + await pxe.addNote(recipientAddress, token.address, storageSlot, preimage, receipt.txHash); + + await token.methods.redeem_shield(recipientAddress, mintAmount, secret).send().wait(); + expect(await token.methods.balance_of_private(recipientAddress).view()).toEqual(20n); }, 30_000); }); @@ -145,15 +169,23 @@ describe('guides/dapp/testing', () => { testContract = await TestContract.deploy(owner).send().deployed(); token = await TokenContract.deploy(owner).send().deployed(); await token.methods._initialize(owner.getAddress()).send().wait(); + + const ownerAddress = owner.getAddress(); + const mintAmount = 100n; const secret = Fr.random(); const secretHash = await computeMessageSecretHash(secret); - await token.methods.mint_private(100n, secretHash).send().wait(); - await token.methods.redeem_shield(owner.getAddress(), 100n, secret).send().wait(); + const receipt = await token.methods.mint_private(100n, secretHash).send().wait(); + + const storageSlot = new Fr(5); + const preimage = new NotePreimage([new Fr(mintAmount), secretHash]); + await pxe.addNote(ownerAddress, token.address, storageSlot, preimage, receipt.txHash); + + await token.methods.redeem_shield(ownerAddress, 100n, secret).send().wait(); // docs:start:calc-slot cheats = await CheatCodes.create(ETHEREUM_HOST, pxe); // The balances mapping is defined on storage slot 3 and is indexed by user address - ownerSlot = cheats.aztec.computeSlotInMap(3n, owner.getAddress()); + ownerSlot = cheats.aztec.computeSlotInMap(3n, ownerAddress); // docs:end:calc-slot }, 60_000); diff --git a/yarn-project/end-to-end/src/guides/up_quick_start.sh b/yarn-project/end-to-end/src/guides/up_quick_start.sh index 3fc69fe632f..2ad7e7eab78 100755 --- a/yarn-project/end-to-end/src/guides/up_quick_start.sh +++ b/yarn-project/end-to-end/src/guides/up_quick_start.sh @@ -29,11 +29,17 @@ aztec-cli send _initialize \ SECRET="0x29bf6afaf29f61cbcf2a4fa7da97be481fb418dc08bdab5338839974beb7b49f" SECRET_HASH="0x0a42b1fe22b652cc8610e33bb1128040ce2d2862e7041ff235aa871739822b74" -aztec-cli send mint_private \ +MINT_PRIVATE_OUTPUT=$(aztec-cli send mint_private \ --args 1000 $SECRET_HASH \ --contract-abi TokenContractAbi \ --contract-address $CONTRACT \ - --private-key $ALICE_PRIVATE_KEY + --private-key $ALICE_PRIVATE_KEY) + +MINT_PRIVATE_TX_HASH=$(echo "$MINT_PRIVATE_OUTPUT" | grep "Transaction hash:" | awk '{print $NF}') + +aztec-cli add-note \ + $ALICE $CONTRACT 5 $MINT_PRIVATE_TX_HASH \ + --preimage 1000 $SECRET_HASH aztec-cli send redeem_shield \ --args $ALICE 1000 $SECRET \ diff --git a/yarn-project/end-to-end/src/guides/writing_an_account_contract.test.ts b/yarn-project/end-to-end/src/guides/writing_an_account_contract.test.ts index eb58f3f19a6..4e66831c2d9 100644 --- a/yarn-project/end-to-end/src/guides/writing_an_account_contract.test.ts +++ b/yarn-project/end-to-end/src/guides/writing_an_account_contract.test.ts @@ -4,6 +4,7 @@ import { BaseAccountContract, CompleteAddress, Fr, + NotePreimage, computeMessageSecretHash, } from '@aztec/aztec.js'; import { GrumpkinPrivateKey, GrumpkinScalar } from '@aztec/circuits.js'; @@ -67,8 +68,14 @@ describe('guides/writing_an_account_contract', () => { const secret = Fr.random(); const secretHash = await computeMessageSecretHash(secret); - await token.methods.mint_private(50, secretHash).send().wait(); - await token.methods.redeem_shield({ address }, 50, secret).send().wait(); + const mintAmount = 50n; + const receipt = await token.methods.mint_private(mintAmount, secretHash).send().wait(); + + const storageSlot = new Fr(5); + const preimage = new NotePreimage([new Fr(mintAmount), secretHash]); + await pxe.addNote(address, token.address, storageSlot, preimage, receipt.txHash); + + await token.methods.redeem_shield({ address }, mintAmount, secret).send().wait(); const balance = await token.methods.balance_of_private({ address }).view(); logger(`Balance of wallet is now ${balance}`); diff --git a/yarn-project/end-to-end/src/sample-dapp/index.mjs b/yarn-project/end-to-end/src/sample-dapp/index.mjs index 32d8e256692..db69c2b26af 100644 --- a/yarn-project/end-to-end/src/sample-dapp/index.mjs +++ b/yarn-project/end-to-end/src/sample-dapp/index.mjs @@ -1,6 +1,7 @@ import { Fr, L2BlockL2Logs, + NotePreimage, computeMessageSecretHash, createPXEClient, getSandboxAccountsWallets, @@ -40,7 +41,12 @@ async function mintPrivateFunds(pxe) { const mintAmount = 20n; const secret = Fr.random(); const secretHash = await computeMessageSecretHash(secret); - await token.methods.mint_private(mintAmount, secretHash).send().wait(); + const receipt = await token.methods.mint_private(mintAmount, secretHash).send().wait(); + + const storageSlot = new Fr(5); + const preimage = new NotePreimage([new Fr(mintAmount), secretHash]); + await pxe.addNote(owner.getAddress(), token.address, storageSlot, preimage, receipt.txHash); + await token.methods.redeem_shield(owner.getAddress(), mintAmount, secret).send().wait(); await showPrivateBalances(pxe); diff --git a/yarn-project/end-to-end/src/sample-dapp/index.test.mjs b/yarn-project/end-to-end/src/sample-dapp/index.test.mjs index 0b52196b14d..04d0bc2a227 100644 --- a/yarn-project/end-to-end/src/sample-dapp/index.test.mjs +++ b/yarn-project/end-to-end/src/sample-dapp/index.test.mjs @@ -1,5 +1,5 @@ import { createSandbox } from '@aztec/aztec-sandbox'; -import { Contract, Fr, computeMessageSecretHash, createAccount } from '@aztec/aztec.js'; +import { Contract, Fr, NotePreimage, computeMessageSecretHash, createAccount } from '@aztec/aztec.js'; import { TokenContractAbi } from '@aztec/noir-contracts/artifacts'; describe('token', () => { @@ -16,7 +16,12 @@ describe('token', () => { const initialBalance = 20n; const secret = Fr.random(); const secretHash = await computeMessageSecretHash(secret); - await token.methods.mint_private(initialBalance, secretHash).send().wait(); + const receipt = await token.methods.mint_private(initialBalance, secretHash).send().wait(); + + const storageSlot = new Fr(5); + const preimage = new NotePreimage([new Fr(initialBalance), secretHash]); + await pxe.addNote(owner.getAddress(), token.address, storageSlot, preimage, receipt.txHash); + await token.methods.redeem_shield({ address: owner.getAddress() }, initialBalance, secret).send().wait(); }, 120_000); diff --git a/yarn-project/noir-contracts/src/contracts/card_game_contract/src/main.nr b/yarn-project/noir-contracts/src/contracts/card_game_contract/src/main.nr index 07370a23482..de7e017d67e 100644 --- a/yarn-project/noir-contracts/src/contracts/card_game_contract/src/main.nr +++ b/yarn-project/noir-contracts/src/contracts/card_game_contract/src/main.nr @@ -252,7 +252,7 @@ contract CardGame { // Note 1: Needs to be defined by every contract producing logs. // Note 2: Having it in all the contracts gives us the ability to compute the note hash and nullifier differently for different kind of notes. unconstrained fn compute_note_hash_and_nullifier(contract_address: Field, nonce: Field, storage_slot: Field, preimage: [Field; VALUE_NOTE_LEN]) -> [Field; 4] { - let note_header = NoteHeader { contract_address, nonce, storage_slot }; + let note_header = NoteHeader::new(contract_address, nonce, storage_slot); note_utils::compute_note_hash_and_nullifier(ValueNoteMethods, note_header, preimage) } } diff --git a/yarn-project/noir-contracts/src/contracts/docs_example_contract/src/actions.nr b/yarn-project/noir-contracts/src/contracts/docs_example_contract/src/actions.nr index 28c43227c25..75bbb65572a 100644 --- a/yarn-project/noir-contracts/src/contracts/docs_example_contract/src/actions.nr +++ b/yarn-project/noir-contracts/src/contracts/docs_example_contract/src/actions.nr @@ -145,16 +145,6 @@ unconstrained fn get_total_points( total_points } -// docs:start:state_vars-SetContains -fn assert_contains_card( - state_var: Set, - card: &mut CardNote, - nonce: Field, -) { - state_var.assert_contains_and_remove(card, nonce); -} -// docs:end:state_vars-SetContains - // docs:start:state_vars-MapAtSingletonInit fn add_new_profile( state_var: Map>, diff --git a/yarn-project/noir-contracts/src/contracts/docs_example_contract/src/types/profile_note.nr b/yarn-project/noir-contracts/src/contracts/docs_example_contract/src/types/profile_note.nr index 2a25e726bf2..e287d8ab544 100644 --- a/yarn-project/noir-contracts/src/contracts/docs_example_contract/src/types/profile_note.nr +++ b/yarn-project/noir-contracts/src/contracts/docs_example_contract/src/types/profile_note.nr @@ -1,7 +1,6 @@ use dep::aztec::note::{ note_header::NoteHeader, note_interface::NoteInterface, - utils::compute_note_hash_for_read_or_nullify, }; global PROFILE_NOTE_LEN: Field = 2; diff --git a/yarn-project/noir-contracts/src/contracts/docs_example_contract/src/types/rules_note.nr b/yarn-project/noir-contracts/src/contracts/docs_example_contract/src/types/rules_note.nr index 1492f56127f..e67c116e961 100644 --- a/yarn-project/noir-contracts/src/contracts/docs_example_contract/src/types/rules_note.nr +++ b/yarn-project/noir-contracts/src/contracts/docs_example_contract/src/types/rules_note.nr @@ -1,7 +1,6 @@ use dep::aztec::note::{ note_header::NoteHeader, note_interface::NoteInterface, - utils::compute_note_hash_for_read_or_nullify, }; global RULES_NOTE_LEN: Field = 2; diff --git a/yarn-project/noir-contracts/src/contracts/easy_private_token_contract/src/main.nr b/yarn-project/noir-contracts/src/contracts/easy_private_token_contract/src/main.nr index 3605eb73516..6b0007eb51b 100644 --- a/yarn-project/noir-contracts/src/contracts/easy_private_token_contract/src/main.nr +++ b/yarn-project/noir-contracts/src/contracts/easy_private_token_contract/src/main.nr @@ -91,7 +91,7 @@ contract EasyPrivateToken { // Note 1: Needs to be defined by every contract producing logs. // Note 2: Having it in all the contracts gives us the ability to compute the note hash and nullifier differently for different kind of notes. unconstrained fn compute_note_hash_and_nullifier(contract_address: Field, nonce: Field, storage_slot: Field, preimage: [Field; VALUE_NOTE_LEN]) -> [Field; 4] { - let note_header = NoteHeader { contract_address, nonce, storage_slot }; + let note_header = NoteHeader::new(contract_address, nonce, storage_slot); note_utils::compute_note_hash_and_nullifier(ValueNoteMethods, note_header, preimage) } } diff --git a/yarn-project/noir-contracts/src/contracts/ecdsa_account_contract/src/main.nr b/yarn-project/noir-contracts/src/contracts/ecdsa_account_contract/src/main.nr index be516af65a3..75f6f48802e 100644 --- a/yarn-project/noir-contracts/src/contracts/ecdsa_account_contract/src/main.nr +++ b/yarn-project/noir-contracts/src/contracts/ecdsa_account_contract/src/main.nr @@ -109,7 +109,7 @@ contract EcdsaAccount { // Note 2: Having it in all the contracts gives us the ability to compute the note hash and nullifier differently for different kind of notes. unconstrained fn compute_note_hash_and_nullifier(contract_address: Field, nonce: Field, storage_slot: Field, preimage: [Field; ECDSA_PUBLIC_KEY_NOTE_LEN]) -> [Field; 4] { assert(storage_slot == 1); - let note_header = NoteHeader { contract_address, nonce, storage_slot }; + let note_header = NoteHeader::new(contract_address, nonce, storage_slot); note_utils::compute_note_hash_and_nullifier(EcdsaPublicKeyNoteInterface, note_header, preimage) } } diff --git a/yarn-project/noir-contracts/src/contracts/escrow_contract/src/main.nr b/yarn-project/noir-contracts/src/contracts/escrow_contract/src/main.nr index 48a37102513..9eb7c7a21b9 100644 --- a/yarn-project/noir-contracts/src/contracts/escrow_contract/src/main.nr +++ b/yarn-project/noir-contracts/src/contracts/escrow_contract/src/main.nr @@ -86,7 +86,7 @@ contract Escrow { } unconstrained fn compute_note_hash_and_nullifier(contract_address: Field, nonce: Field, storage_slot: Field, preimage: [Field; ADDRESS_NOTE_LEN]) -> [Field; 4] { - let note_header = NoteHeader { contract_address, nonce, storage_slot }; + let note_header = NoteHeader::new(contract_address, nonce, storage_slot); assert(storage_slot == 1); note_utils::compute_note_hash_and_nullifier(AddressNoteMethods, note_header, preimage) } diff --git a/yarn-project/noir-contracts/src/contracts/non_native_token_contract/src/main.nr b/yarn-project/noir-contracts/src/contracts/non_native_token_contract/src/main.nr index 5aef07bcf30..49e06ac3a91 100644 --- a/yarn-project/noir-contracts/src/contracts/non_native_token_contract/src/main.nr +++ b/yarn-project/noir-contracts/src/contracts/non_native_token_contract/src/main.nr @@ -35,6 +35,7 @@ contract NonNativeToken { use dep::aztec::{ context::{PrivateContext, PublicContext, Context}, note::{ + note_getter_options::NoteGetterOptions, note_header::NoteHeader, utils as note_utils, }, @@ -243,13 +244,16 @@ contract NonNativeToken { secret: Field, owner: Field, ) { - let pending_shields = storage.pending_shields; - let mut public_note = TransparentNote::new_from_secret(amount, secret); + // Find the note that has the exact amount and secret hash. + let secret_hash = TransparentNote::compute_secret_hash(secret); + let options = NoteGetterOptions::new().select(0, amount).select(1, secret_hash).set_limit(1); + let notes = pending_shields.get_notes(options); + let note = notes[0].unwrap_unchecked(); - // Ensure that the note exists in the tree and remove it. - pending_shields.assert_contains_and_remove_publicly_created(&mut public_note); + // Remove the note so that it can't be redeemed again. + pending_shields.remove(note); // Mint the tokens let balance = storage.balances.at(owner); @@ -301,7 +305,7 @@ contract NonNativeToken { // Note 1: Needs to be defined by every contract producing logs. // Note 2: Having it in all the contracts gives us the ability to compute the note hash and nullifier differently for different kind of notes. unconstrained fn compute_note_hash_and_nullifier(contract_address: Field, nonce: Field, storage_slot: Field, preimage: [Field; VALUE_NOTE_LEN]) -> [Field; 4] { - let note_header = NoteHeader { contract_address, nonce, storage_slot }; + let note_header = NoteHeader::new(contract_address, nonce, storage_slot); if (storage_slot == 2) { note_utils::compute_note_hash_and_nullifier(TransparentNoteMethods, note_header, preimage) } else { diff --git a/yarn-project/noir-contracts/src/contracts/pending_commitments_contract/src/main.nr b/yarn-project/noir-contracts/src/contracts/pending_commitments_contract/src/main.nr index e530a6f31e3..4651536956c 100644 --- a/yarn-project/noir-contracts/src/contracts/pending_commitments_contract/src/main.nr +++ b/yarn-project/noir-contracts/src/contracts/pending_commitments_contract/src/main.nr @@ -291,7 +291,7 @@ contract PendingCommitments { // Note 1: Needs to be defined by every contract producing logs. // Note 2: Having it in all the contracts gives us the ability to compute the note hash and nullifier differently for different kind of notes. unconstrained fn compute_note_hash_and_nullifier(contract_address: Field, nonce: Field, storage_slot: Field, preimage: [Field; VALUE_NOTE_LEN]) -> [Field; 4] { - let note_header = NoteHeader { contract_address, nonce, storage_slot }; + let note_header = NoteHeader::new(contract_address, nonce, storage_slot); note_utils::compute_note_hash_and_nullifier(ValueNoteMethods, note_header, preimage) } } \ No newline at end of file diff --git a/yarn-project/noir-contracts/src/contracts/pokeable_token_contract/src/main.nr b/yarn-project/noir-contracts/src/contracts/pokeable_token_contract/src/main.nr index c3d5bf5aff4..73435133b93 100644 --- a/yarn-project/noir-contracts/src/contracts/pokeable_token_contract/src/main.nr +++ b/yarn-project/noir-contracts/src/contracts/pokeable_token_contract/src/main.nr @@ -120,7 +120,7 @@ contract PokeableToken { // Note 1: Needs to be defined by every contract producing logs. // Note 2: Having it in all the contracts gives us the ability to compute the note hash and nullifier differently for different kind of notes. unconstrained fn compute_note_hash_and_nullifier(contract_address: Field, nonce: Field, storage_slot: Field, preimage: [Field; VALUE_NOTE_LEN]) -> [Field; 4] { - let note_header = NoteHeader { contract_address, nonce, storage_slot }; + let note_header = NoteHeader::new(contract_address, nonce, storage_slot); if (storage_slot == 1) | (storage_slot == 2) { note_utils::compute_note_hash_and_nullifier(AddressNoteMethods, note_header, preimage) } else { diff --git a/yarn-project/noir-contracts/src/contracts/private_token_airdrop_contract/src/interface.nr b/yarn-project/noir-contracts/src/contracts/private_token_airdrop_contract/src/interface.nr index 848c52b87ab..babfad8d325 100644 --- a/yarn-project/noir-contracts/src/contracts/private_token_airdrop_contract/src/interface.nr +++ b/yarn-project/noir-contracts/src/contracts/private_token_airdrop_contract/src/interface.nr @@ -58,17 +58,13 @@ impl PrivateTokenAirdropPrivateContextInterface { self, context: &mut PrivateContext, amount: Field, - secret: Field, - owner: Field, - nonce: Field + secret: Field ) -> [Field; RETURN_VALUES_LENGTH] { - let mut serialized_args = [0; 4]; + let mut serialized_args = [0; 2]; serialized_args[0] = amount; serialized_args[1] = secret; - serialized_args[2] = owner; - serialized_args[3] = nonce; - context.call_private_function(self.address, 0xa9220f0f, serialized_args) + context.call_private_function(self.address, 0xe642f6a0, serialized_args) } diff --git a/yarn-project/noir-contracts/src/contracts/private_token_airdrop_contract/src/main.nr b/yarn-project/noir-contracts/src/contracts/private_token_airdrop_contract/src/main.nr index 5118a874d78..795a1c77a8f 100644 --- a/yarn-project/noir-contracts/src/contracts/private_token_airdrop_contract/src/main.nr +++ b/yarn-project/noir-contracts/src/contracts/private_token_airdrop_contract/src/main.nr @@ -51,8 +51,6 @@ contract PrivateTokenAirdrop { initial_supply: Field, owner: Field ) { - - // Insert new note to a set of user notes and emit the newly created encrypted note preimage via oracle call. let owner_balance = storage.balances.at(owner); if (initial_supply != 0) { @@ -66,8 +64,6 @@ contract PrivateTokenAirdrop { amount: Field, owner: Field ) { - - // Insert new note to a set of user notes and emit the newly created encrypted note preimage via oracle call. let owner_balance = storage.balances.at(owner); increment(owner_balance, amount, owner); @@ -80,7 +76,6 @@ contract PrivateTokenAirdrop { amount: Field, owner: Field, ) { - let msg_sender = context.msg_sender(); let this_address = context.this_address(); @@ -109,8 +104,6 @@ contract PrivateTokenAirdrop { amount: Field, recipient: Field, ) { - - let sender = context.msg_sender(); let sender_balance = storage.balances.at(sender); @@ -139,7 +132,6 @@ contract PrivateTokenAirdrop { amounts: [Field; MAX_NEW_COMMITMENTS_PER_CALL], secrets: [Field; MAX_NEW_COMMITMENTS_PER_CALL], ) { - let sender = context.msg_sender(); // Pick from the set of sender's notes to spend amount. @@ -159,21 +151,20 @@ contract PrivateTokenAirdrop { } #[aztec(private)] - fn claim( - amount: Field, - secret: Field, - owner: Field, - nonce: Field, - ) { - + fn claim(amount: Field, secret: Field) { + let owner = context.msg_sender(); + + // Find a claim note with the exact amount (field_index = 0) and secret (field_index = 1). + let options = NoteGetterOptions::new().select(0, amount).select(1, secret).set_limit(1); + let opt_notes = storage.claims.get_notes(options); + let note = opt_notes[0].unwrap_unchecked(); - // Remove the claim note if it exists in the set. - let mut note = ClaimNote::new(amount, secret); - storage.claims.assert_contains_and_remove(&mut note, nonce); + // Remove the claim note from the set. + storage.claims.remove(note); // Send the value note. let balance = storage.balances.at(owner); - increment(balance, amount, owner); + increment(balance, note.value, owner); } // Transfers `amounts` of tokens from `sender` to 3 `recipients`. @@ -186,8 +177,6 @@ contract PrivateTokenAirdrop { recipients: [Field; 3], spend_note_offset: u32, ) { - - // Gets the set of sender's notes and picks 4 of those based on the offset. // Spends the first of those 4 notes. let sender_balance = storage.balances.at(sender); @@ -227,8 +216,6 @@ contract PrivateTokenAirdrop { unconstrained fn getBalance( owner: Field, ) -> Field { - - // Get the set of notes owned by the user. let owner_balance = storage.balances.at(owner); @@ -240,7 +227,7 @@ contract PrivateTokenAirdrop { // Note 1: Needs to be defined by every contract producing logs. // Note 2: Having it in all the contracts gives us the ability to compute the note hash and nullifier differently for different kind of notes. unconstrained fn compute_note_hash_and_nullifier(contract_address: Field, nonce: Field, storage_slot: Field, preimage: [Field; VALUE_NOTE_LEN]) -> [Field; 4] { - let note_header = NoteHeader { contract_address, nonce, storage_slot }; + let note_header = NoteHeader::new(contract_address, nonce, storage_slot); if (storage_slot == 2) { note_utils::compute_note_hash_and_nullifier(ClaimNoteMethods, note_header, preimage) } else { diff --git a/yarn-project/noir-contracts/src/contracts/private_token_contract/src/main.nr b/yarn-project/noir-contracts/src/contracts/private_token_contract/src/main.nr index 45116069762..c999ee9939e 100644 --- a/yarn-project/noir-contracts/src/contracts/private_token_contract/src/main.nr +++ b/yarn-project/noir-contracts/src/contracts/private_token_contract/src/main.nr @@ -97,11 +97,9 @@ contract PrivateToken { // Computes note hash and nullifier. // Note 1: Needs to be defined by every contract producing logs. // Note 2: Having it in all the contracts gives us the ability to compute the note hash and nullifier differently for different kind of notes. - // docs:start:compute_note_hash_and_nullifier unconstrained fn compute_note_hash_and_nullifier(contract_address: Field, nonce: Field, storage_slot: Field, preimage: [Field; VALUE_NOTE_LEN]) -> [Field; 4] { - let note_header = NoteHeader { contract_address, nonce, storage_slot }; + let note_header = NoteHeader::new(contract_address, nonce, storage_slot); note_utils::compute_note_hash_and_nullifier(ValueNoteMethods, note_header, preimage) } - // docs:end:compute_note_hash_and_nullifier } // docs:end:all \ No newline at end of file diff --git a/yarn-project/noir-contracts/src/contracts/schnorr_account_contract/src/main.nr b/yarn-project/noir-contracts/src/contracts/schnorr_account_contract/src/main.nr index c2483dfa1a4..f59434c097c 100644 --- a/yarn-project/noir-contracts/src/contracts/schnorr_account_contract/src/main.nr +++ b/yarn-project/noir-contracts/src/contracts/schnorr_account_contract/src/main.nr @@ -107,7 +107,7 @@ contract SchnorrAccount { // Note 2: Having it in all the contracts gives us the ability to compute the note hash and nullifier differently for different kind of notes. unconstrained fn compute_note_hash_and_nullifier(contract_address: Field, nonce: Field, storage_slot: Field, preimage: [Field; PUBLIC_KEY_NOTE_LEN]) -> [Field; 4] { assert(storage_slot == 1); - let note_header = NoteHeader { contract_address, nonce, storage_slot }; + let note_header = NoteHeader::new(contract_address, nonce, storage_slot); note_utils::compute_note_hash_and_nullifier(PublicKeyNoteMethods, note_header, preimage) } } diff --git a/yarn-project/noir-contracts/src/contracts/stateful_test_contract/src/main.nr b/yarn-project/noir-contracts/src/contracts/stateful_test_contract/src/main.nr index 3c0941b741c..566f4e74110 100644 --- a/yarn-project/noir-contracts/src/contracts/stateful_test_contract/src/main.nr +++ b/yarn-project/noir-contracts/src/contracts/stateful_test_contract/src/main.nr @@ -93,7 +93,7 @@ contract StatefulTest { } unconstrained fn compute_note_hash_and_nullifier(contract_address: Field, nonce: Field, storage_slot: Field, preimage: [Field; VALUE_NOTE_LEN]) -> [Field; 4] { - let note_header = NoteHeader { contract_address, nonce, storage_slot }; + let note_header = NoteHeader::new(contract_address, nonce, storage_slot); note_utils::compute_note_hash_and_nullifier(ValueNoteMethods, note_header, preimage) } } diff --git a/yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr b/yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr index 2cf48a52994..46801de0933 100644 --- a/yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr +++ b/yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr @@ -18,6 +18,7 @@ contract Token { use dep::aztec::{ note::{ + note_getter_options::NoteGetterOptions, note_header::NoteHeader, utils as note_utils, }, @@ -274,11 +275,11 @@ contract Token { secret: Field, ) -> Field { let pending_shields = storage.pending_shields; - let mut public_note = TransparentNote::new_from_secret(amount, secret); - - // docs:start:assert_contains_and_remove_publicly_created - pending_shields.assert_contains_and_remove_publicly_created(&mut public_note); - // docs:end:assert_contains_and_remove_publicly_created + let secret_hash = TransparentNote::compute_secret_hash(secret); + let options = NoteGetterOptions::new().select(0, amount).select(1, secret_hash).set_limit(1); + let notes = pending_shields.get_notes(options); + let note = notes[0].unwrap_unchecked(); + pending_shields.remove(note); storage.balances.at(to).add(SafeU120::new(amount)); @@ -444,7 +445,7 @@ contract Token { // Note 1: Needs to be defined by every contract producing logs. // Note 2: Having it in all the contracts gives us the ability to compute the note hash and nullifier differently for different kind of notes. unconstrained fn compute_note_hash_and_nullifier(contract_address: Field, nonce: Field, storage_slot: Field, preimage: [Field; TOKEN_NOTE_LEN]) -> [Field; 4] { - let note_header = NoteHeader { contract_address, nonce, storage_slot }; + let note_header = NoteHeader::new(contract_address, nonce, storage_slot); if (storage_slot == 5) { note_utils::compute_note_hash_and_nullifier(TransparentNoteMethods, note_header, preimage) } else { @@ -452,6 +453,5 @@ contract Token { } } // docs:end:compute_note_hash_and_nullifier - } // docs:end:token_all diff --git a/yarn-project/pxe/src/pxe_service/pxe_service.ts b/yarn-project/pxe/src/pxe_service/pxe_service.ts index 88efb0e5b30..40c185cf6ec 100644 --- a/yarn-project/pxe/src/pxe_service/pxe_service.ts +++ b/yarn-project/pxe/src/pxe_service/pxe_service.ts @@ -42,7 +42,6 @@ import { NodeInfo, NotePreimage, PXE, - PublicKey, SimulationError, Tx, TxExecutionRequest, @@ -201,12 +200,25 @@ export class PXEService implements PXE { } public async addNote( + account: AztecAddress, contractAddress: AztecAddress, storageSlot: Fr, preimage: NotePreimage, - nonce: Fr, - account: PublicKey, + txHash: TxHash, + nonce?: Fr, ) { + const { publicKey } = (await this.db.getCompleteAddress(account)) ?? {}; + if (!publicKey) { + throw new Error('Unknown account.'); + } + + if (!nonce) { + [nonce] = await this.getNoteNonces(contractAddress, storageSlot, preimage, txHash); + } + if (!nonce) { + throw new Error(`Cannot find the note in tx: ${txHash}.`); + } + const { innerNoteHash, siloedNoteHash, uniqueSiloedNoteHash, innerNullifier } = await this.simulator.computeNoteHashAndNullifier(contractAddress, nonce, storageSlot, preimage.items); @@ -225,7 +237,6 @@ export class PXEService implements PXE { throw new Error('The note has been destroyed.'); } - // TODO - Should not modify the db while syncing. await this.db.addNoteSpendingInfo({ contractAddress, storageSlot, @@ -234,7 +245,7 @@ export class PXEService implements PXE { innerNoteHash, siloedNullifier, index, - publicKey: account, + publicKey, }); } @@ -259,16 +270,23 @@ export class PXEService implements PXE { if (commitment.equals(Fr.ZERO)) break; const nonce = computeCommitmentNonce(wasm, firstNullifier, i); - const { uniqueSiloedNoteHash } = await this.simulator.computeNoteHashAndNullifier( + const { siloedNoteHash, uniqueSiloedNoteHash } = await this.simulator.computeNoteHashAndNullifier( contractAddress, nonce, storageSlot, preimage.items, ); + // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386) + // Remove this once notes added from public also include nonces. + if (commitment.equals(siloedNoteHash)) { + nonces.push(Fr.ZERO); + break; + } if (commitment.equals(uniqueSiloedNoteHash)) { nonces.push(nonce); } } + return nonces; } diff --git a/yarn-project/types/src/interfaces/pxe.ts b/yarn-project/types/src/interfaces/pxe.ts index c2d542d6abe..cd61e82b5ba 100644 --- a/yarn-project/types/src/interfaces/pxe.ts +++ b/yarn-project/types/src/interfaces/pxe.ts @@ -7,7 +7,6 @@ import { L2BlockL2Logs, L2Tx, NotePreimage, - PublicKey, Tx, TxExecutionRequest, TxHash, @@ -172,18 +171,20 @@ export interface PXE { /** * Adds a note to the database. Throw if the note hash of the note doesn't exist in the tree. + * @param account - The account the note is associated with. * @param contract - The contract address of the note. * @param storageSlot - The storage slot of the note. * @param preimage - The note preimage. - * @param nonce - The nonce of the note. - * @param account - The public key of the account the note is associated with. + * @param txHash - The tx hash of the tx containing the note. + * @param nonce - The nonce of the note. If undefined, will look for the first index that matches the preimage. */ addNote( + account: AztecAddress, contract: AztecAddress, storageSlot: Fr, preimage: NotePreimage, - nonce: Fr, - account: PublicKey, + txHash: TxHash, + nonce?: Fr, ): Promise; /** From 78bd1a36805bd6508155a62bef06cf223bc67948 Mon Sep 17 00:00:00 2001 From: Rahul Kothari Date: Mon, 2 Oct 2023 13:10:10 +0100 Subject: [PATCH 3/4] chore: move hash utils to aztec-nr (#2583) created #2616 to create a similar method for byteutils --- .../communication/cross_chain_calls.md | 2 +- docs/docs/dev_docs/contracts/portals/main.md | 14 +++ .../writing_dapp/contract_deployment.md | 6 +- l1-contracts/test/portals/TokenPortal.sol | 2 + yarn-project/aztec-nr/aztec/src/hash.nr | 36 +++++++ yarn-project/aztec-nr/aztec/src/lib.nr | 1 + .../aztec/src/messaging/l1_to_l2_message.nr | 16 +-- .../ecdsa_account_contract/src/main.nr | 1 - .../src/main.nr | 1 - .../token_bridge_contract/src/main.nr | 3 +- .../token_bridge_contract/src/util.nr | 101 +++++------------- .../src/contracts/token_contract/src/main.nr | 5 +- .../src/types/transparent_note.nr | 12 +-- .../src/contracts/token_contract/src/util.nr | 10 -- .../contracts/uniswap_contract/src/main.nr | 3 +- .../contracts/uniswap_contract/src/util.nr | 44 +------- 16 files changed, 96 insertions(+), 161 deletions(-) create mode 100644 yarn-project/aztec-nr/aztec/src/hash.nr delete mode 100644 yarn-project/noir-contracts/src/contracts/token_contract/src/util.nr diff --git a/docs/docs/concepts/foundation/communication/cross_chain_calls.md b/docs/docs/concepts/foundation/communication/cross_chain_calls.md index 86554a82090..abd37f84fcf 100644 --- a/docs/docs/concepts/foundation/communication/cross_chain_calls.md +++ b/docs/docs/concepts/foundation/communication/cross_chain_calls.md @@ -96,7 +96,7 @@ For the sake of cross-chain messages, this means inserting and nullifying L1 $\r ### Messages -While a message could theoretically be arbitrary long, we want to limit the cost of the insertion on L1 as much as possible. Therefore, we allow the users to send 32 bytes of "content" between L1 and L2. If 32 suffices, no packing required. If the 32 is too "small" for the message directly, the sender should simply pass along a `sha256(content)` instead of the content directly. The content can then either be emitted as an event on L2 or kept by the sender, who should then be the only entity that can "unpack" the message. +While a message could theoretically be arbitrary long, we want to limit the cost of the insertion on L1 as much as possible. Therefore, we allow the users to send 32 bytes of "content" between L1 and L2. If 32 suffices, no packing required. If the 32 is too "small" for the message directly, the sender should simply pass along a `sha256(content)` instead of the content directly (note that this hash should fit in a field element which is ~254 bits. More info on this below). The content can then either be emitted as an event on L2 or kept by the sender, who should then be the only entity that can "unpack" the message. In this manner, there is some way to "unpack" the content on the receiving domain. The message that is passed along, require the `sender/recipient` pair to be communicated as well (we need to know who should receive the message and be able to check). By having the pending messages be a contract on L1, we can ensure that the `sender = msg.sender` and let only `content` and `recipient` be provided by the caller. Summing up, we can use the struct's seen below, and only store the commitment (`sha256(LxToLyMsg)`) on chain or in the trees, this way, we need only update a single storage slot per message. diff --git a/docs/docs/dev_docs/contracts/portals/main.md b/docs/docs/dev_docs/contracts/portals/main.md index 0ff0bc24d40..e1450b98140 100644 --- a/docs/docs/dev_docs/contracts/portals/main.md +++ b/docs/docs/dev_docs/contracts/portals/main.md @@ -47,6 +47,20 @@ Computing the `content` must be done manually in its current form, as we are sti #include_code claim_public /yarn-project/noir-contracts/src/contracts/token_bridge_contract/src/main.nr rust +:::info +The `content_hash` is a sha256 truncated to a field element (~ 254 bits). In Aztec-nr, you can use our `sha256_to_field()` to do a sha256 hash which fits in one field element: + +#include_code mint_public_content_hash_nr /yarn-project/noir-contracts/src/contracts/token_bridge_contract/src/util.nr rust + +In solidity, you can use our `Hash.sha256ToField()` method: + +#include_code content_hash_sol_import l1-contracts/test/portals/TokenPortal.sol solidity + +#include_code deposit_public l1-contracts/test/portals/TokenPortal.sol solidity + +The `secret_hash` uses the pederson hash which fits in a field element. You can use the utility method `computeMessageSecretHash()`in `@aztec/aztec.js` npm package to generate a secret and its corresponding hash. +::: + After the transaction has been mined, the message is consumed, a nullifier is emitted and the tokens have been minted on Aztec and are ready for claiming. Since the message consumption is emitting a nullifier the same message cannot be consumed again. The index in the message tree is used as part of the nullifier computation, ensuring that the same content and secret being inserted will be distinct messages that can each be consumed. Without the index in the nullifier, it would be possible to perform a kind of attack known as `Faerie Gold` attacks where two seemingly good messages are inserted, but only one of them can be consumed later. diff --git a/docs/docs/dev_docs/tutorials/writing_dapp/contract_deployment.md b/docs/docs/dev_docs/tutorials/writing_dapp/contract_deployment.md index 9155fd48be1..d91c0b3db30 100644 --- a/docs/docs/dev_docs/tutorials/writing_dapp/contract_deployment.md +++ b/docs/docs/dev_docs/tutorials/writing_dapp/contract_deployment.md @@ -28,16 +28,12 @@ Last, copy-paste the code from the `Token` contract into `contracts/token/main.n #include_code token_all yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr rust -The `Token` contract also requires two helper files. Copy-them too: +The `Token` contract also requires a helper file. Copy it too: Create `contracts/token/types.nr` and copy-paste the following: #include_code token_types_all yarn-project/noir-contracts/src/contracts/token_contract/src/types/transparent_note.nr rust -Finally, create `contracts/token/util.nr` and copy-paste the following: - -#include_code token_util_all yarn-project/noir-contracts/src/contracts/token_contract/src/util.nr rust - ## Compile your contract We'll now use the [Aztec CLI](../../cli/main.md) to [compile](../../contracts/compiling.md) our project. If you haven't installed the CLI already, you can install it locally to your project running: diff --git a/l1-contracts/test/portals/TokenPortal.sol b/l1-contracts/test/portals/TokenPortal.sol index 37d5f5cb472..ed04aa8dd60 100644 --- a/l1-contracts/test/portals/TokenPortal.sol +++ b/l1-contracts/test/portals/TokenPortal.sol @@ -7,7 +7,9 @@ import {SafeERC20} from "@oz/token/ERC20/utils/SafeERC20.sol"; import {IRegistry} from "@aztec/core/interfaces/messagebridge/IRegistry.sol"; import {IInbox} from "@aztec/core/interfaces/messagebridge/IInbox.sol"; import {DataStructures} from "@aztec/core/libraries/DataStructures.sol"; +// docs:start:content_hash_sol_import import {Hash} from "@aztec/core/libraries/Hash.sol"; +// docs:end:content_hash_sol_import contract TokenPortal { using SafeERC20 for IERC20; diff --git a/yarn-project/aztec-nr/aztec/src/hash.nr b/yarn-project/aztec-nr/aztec/src/hash.nr new file mode 100644 index 00000000000..09bdd46f0d3 --- /dev/null +++ b/yarn-project/aztec-nr/aztec/src/hash.nr @@ -0,0 +1,36 @@ +use dep::std::hash::{pedersen_with_separator, sha256}; +use crate::constants_gen::{ + GENERATOR_INDEX__SIGNATURE_PAYLOAD, + GENERATOR_INDEX__L1_TO_L2_MESSAGE_SECRET, +}; + +fn sha256_to_field(bytes_to_hash: [u8; N]) -> Field { + let sha256_hashed = sha256(bytes_to_hash); + + // Convert it to a field element + let mut v = 1; + let mut high = 0 as Field; + let mut low = 0 as Field; + + for i in 0..16 { + high = high + (sha256_hashed[15 - i] as Field) * v; + low = low + (sha256_hashed[16 + 15 - i] as Field) * v; + v = v * 256; + } + + // Abuse that a % p + b % p = (a + b) % p and that low < p + let hash_in_a_field = low + high * v; + + hash_in_a_field +} + +fn compute_message_hash(args: [Field; N]) -> Field { + // @todo @lherskind We should probably use a separate generator for this, + // to avoid any potential collisions with payloads. + pedersen_with_separator(args, GENERATOR_INDEX__SIGNATURE_PAYLOAD)[0] +} + +fn compute_secret_hash(secret: Field) -> Field { + // TODO(#1205) This is probably not the right index to use + pedersen_with_separator([secret], GENERATOR_INDEX__L1_TO_L2_MESSAGE_SECRET)[0] +} \ No newline at end of file diff --git a/yarn-project/aztec-nr/aztec/src/lib.nr b/yarn-project/aztec-nr/aztec/src/lib.nr index 72ebcd052f8..98c8e638bb0 100644 --- a/yarn-project/aztec-nr/aztec/src/lib.nr +++ b/yarn-project/aztec-nr/aztec/src/lib.nr @@ -5,6 +5,7 @@ mod auth; mod constants_gen; mod context; mod entrypoint; +mod hash; mod log; mod messaging; mod note; diff --git a/yarn-project/aztec-nr/aztec/src/messaging/l1_to_l2_message.nr b/yarn-project/aztec-nr/aztec/src/messaging/l1_to_l2_message.nr index 70e5f6efc23..8ac1a932490 100644 --- a/yarn-project/aztec-nr/aztec/src/messaging/l1_to_l2_message.nr +++ b/yarn-project/aztec-nr/aztec/src/messaging/l1_to_l2_message.nr @@ -3,6 +3,7 @@ use crate::constants_gen::{ GENERATOR_INDEX__NULLIFIER, GENERATOR_INDEX__L1_TO_L2_MESSAGE_SECRET, }; +use crate::hash::{sha256_to_field}; struct L1ToL2Message { sender: Field, @@ -64,20 +65,7 @@ impl L1ToL2Message { hash_bytes[i + 224] = fee_bytes[i]; } - let message_sha256 = dep::std::hash::sha256(hash_bytes); - - // Convert the message_sha256 to a field element - let mut v = 1; - let mut high = 0 as Field; - let mut low = 0 as Field; - - for i in 0..16 { - high = high + (message_sha256[15 - i] as Field) * v; - low = low + (message_sha256[16 + 15 - i] as Field) * v; - v = v * 256; - } - - let message_hash = low + high * v; + let message_hash = sha256_to_field(hash_bytes); message_hash } diff --git a/yarn-project/noir-contracts/src/contracts/ecdsa_account_contract/src/main.nr b/yarn-project/noir-contracts/src/contracts/ecdsa_account_contract/src/main.nr index 75f6f48802e..e57ddb7ca18 100644 --- a/yarn-project/noir-contracts/src/contracts/ecdsa_account_contract/src/main.nr +++ b/yarn-project/noir-contracts/src/contracts/ecdsa_account_contract/src/main.nr @@ -7,7 +7,6 @@ contract EcdsaAccount { use dep::std::option::Option; use dep::aztec::{ abi::CallContext, - constants_gen::GENERATOR_INDEX__SIGNATURE_PAYLOAD, context::{PrivateContext, PublicContext, Context}, entrypoint::{EntrypointPayload, ENTRYPOINT_PAYLOAD_SIZE}, log::emit_encrypted_log, diff --git a/yarn-project/noir-contracts/src/contracts/schnorr_hardcoded_account_contract/src/main.nr b/yarn-project/noir-contracts/src/contracts/schnorr_hardcoded_account_contract/src/main.nr index ad591369e08..562e403d1f7 100644 --- a/yarn-project/noir-contracts/src/contracts/schnorr_hardcoded_account_contract/src/main.nr +++ b/yarn-project/noir-contracts/src/contracts/schnorr_hardcoded_account_contract/src/main.nr @@ -6,7 +6,6 @@ contract SchnorrHardcodedAccount { entrypoint::{ EntrypointPayload, ENTRYPOINT_PAYLOAD_SIZE }, abi::{ PrivateCircuitPublicInputs, PrivateContextInputs, Hasher }, types::{ vec::BoundedVec, point::Point }, - constants_gen::GENERATOR_INDEX__SIGNATURE_PAYLOAD, context::PrivateContext, account::AccountActions, oracle::auth_witness::get_auth_witness, diff --git a/yarn-project/noir-contracts/src/contracts/token_bridge_contract/src/main.nr b/yarn-project/noir-contracts/src/contracts/token_bridge_contract/src/main.nr index 88b854ed1e3..ac5563fa835 100644 --- a/yarn-project/noir-contracts/src/contracts/token_bridge_contract/src/main.nr +++ b/yarn-project/noir-contracts/src/contracts/token_bridge_contract/src/main.nr @@ -9,6 +9,7 @@ mod token_interface; contract TokenBridge { use dep::aztec::{ context::{Context}, + hash::{compute_secret_hash}, state_vars::{public_state::PublicState}, types::type_serialization::field_serialization::{ FieldSerializationMethods, FIELD_SERIALIZED_LEN, @@ -18,7 +19,7 @@ contract TokenBridge { }; use crate::token_interface::Token; - use crate::util::{get_mint_public_content_hash, get_mint_private_content_hash, get_withdraw_content_hash, compute_secret_hash}; + use crate::util::{get_mint_public_content_hash, get_mint_private_content_hash, get_withdraw_content_hash}; // Storage structure, containing all storage, and specifying what slots they use. struct Storage { diff --git a/yarn-project/noir-contracts/src/contracts/token_bridge_contract/src/util.nr b/yarn-project/noir-contracts/src/contracts/token_bridge_contract/src/util.nr index 7ecb7d547cd..f03bed15094 100644 --- a/yarn-project/noir-contracts/src/contracts/token_bridge_contract/src/util.nr +++ b/yarn-project/noir-contracts/src/contracts/token_bridge_contract/src/util.nr @@ -1,87 +1,54 @@ -use dep::std::hash::{pedersen_with_separator, sha256}; -use dep::aztec::constants_gen::{ - GENERATOR_INDEX__SIGNATURE_PAYLOAD, - GENERATOR_INDEX__L1_TO_L2_MESSAGE_SECRET, -}; +use dep::std::hash::pedersen_with_separator; +// docs:start:mint_public_content_hash_nr +use dep::aztec::hash::{sha256_to_field}; -fn compute_secret_hash(secret: Field) -> Field { - // TODO(#1205) This is probably not the right index to use - pedersen_with_separator([secret], GENERATOR_INDEX__L1_TO_L2_MESSAGE_SECRET)[0] -} - -// Computes a content hash of a deposit/mint_private message. +// Computes a content hash of a deposit/mint_public message. // Refer TokenPortal.sol for reference on L1. -fn get_mint_private_content_hash(amount: Field, secret_hash_for_redeeming_minted_notes: Field, canceller: Field) -> Field { +fn get_mint_public_content_hash(owner_address: Field, amount: Field, canceller: Field) -> Field { + let mut hash_bytes: [u8; 100] = [0; 100]; let amount_bytes = amount.to_be_bytes(32); - let secret_hash_bytes = secret_hash_for_redeeming_minted_notes.to_be_bytes(32); + let recipient_bytes = owner_address.to_be_bytes(32); let canceller_bytes = canceller.to_be_bytes(32); for i in 0..32 { hash_bytes[i + 4] = amount_bytes[i]; - hash_bytes[i + 36] = secret_hash_bytes[i]; + hash_bytes[i + 36] = recipient_bytes[i]; hash_bytes[i + 68] = canceller_bytes[i]; } - // Function selector: 0x25d46b0f keccak256('mint_private(uint256,bytes32,address)') - hash_bytes[0] = 0x25; - hash_bytes[1] = 0xd4; - hash_bytes[2] = 0x6b; - hash_bytes[3] = 0x0f; - - let content_sha256 = sha256(hash_bytes); - - // // Convert the content_sha256 to a field element - let mut v = 1; - let mut high = 0 as Field; - let mut low = 0 as Field; - - for i in 0..16 { - high = high + (content_sha256[15 - i] as Field) * v; - low = low + (content_sha256[16 + 15 - i] as Field) * v; - v = v * 256; - } + // Function selector: 0x63c9440d keccak256('mint_public(uint256,bytes32,address)') + hash_bytes[0] = 0x63; + hash_bytes[1] = 0xc9; + hash_bytes[2] = 0x44; + hash_bytes[3] = 0x0d; - // Abuse that a % p + b % p = (a + b) % p and that low < p - let content_hash = low + high * v; + let content_hash = sha256_to_field(hash_bytes); content_hash } +// docs:end:mint_public_content_hash_nr -// Computes a content hash of a deposit/mint_public message. +// Computes a content hash of a deposit/mint_private message. // Refer TokenPortal.sol for reference on L1. -fn get_mint_public_content_hash(owner_address: Field, amount: Field, canceller: Field) -> Field { +fn get_mint_private_content_hash(amount: Field, secret_hash_for_redeeming_minted_notes: Field, canceller: Field) -> Field { let mut hash_bytes: [u8; 100] = [0; 100]; let amount_bytes = amount.to_be_bytes(32); - let recipient_bytes = owner_address.to_be_bytes(32); + let secret_hash_bytes = secret_hash_for_redeeming_minted_notes.to_be_bytes(32); let canceller_bytes = canceller.to_be_bytes(32); for i in 0..32 { hash_bytes[i + 4] = amount_bytes[i]; - hash_bytes[i + 36] = recipient_bytes[i]; + hash_bytes[i + 36] = secret_hash_bytes[i]; hash_bytes[i + 68] = canceller_bytes[i]; } - // Function selector: 0x63c9440d keccak256('mint_public(uint256,bytes32,address)') - hash_bytes[0] = 0x63; - hash_bytes[1] = 0xc9; - hash_bytes[2] = 0x44; - hash_bytes[3] = 0x0d; - - let content_sha256 = sha256(hash_bytes); - - // // Convert the content_sha256 to a field element - let mut v = 1; - let mut high = 0 as Field; - let mut low = 0 as Field; - - for i in 0..16 { - high = high + (content_sha256[15 - i] as Field) * v; - low = low + (content_sha256[16 + 15 - i] as Field) * v; - v = v * 256; - } + // Function selector: 0x25d46b0f keccak256('mint_private(uint256,bytes32,address)') + hash_bytes[0] = 0x25; + hash_bytes[1] = 0xd4; + hash_bytes[2] = 0x6b; + hash_bytes[3] = 0x0f; - // Abuse that a % p + b % p = (a + b) % p and that low < p - let content_hash = low + high * v; + let content_hash = sha256_to_field(hash_bytes); content_hash } @@ -107,20 +74,6 @@ fn get_withdraw_content_hash(recipient: Field, amount: Field, callerOnL1: Field) hash_bytes[i + 36] = recipient_bytes[i]; hash_bytes[i + 68] = callerOnL1_bytes[i]; } - let content_sha256 = sha256(hash_bytes); - - // Convert the content_sha256 to a field element - let mut v = 1; - let mut high = 0 as Field; - let mut low = 0 as Field; - - for i in 0..16 { - high = high + (content_sha256[15 - i] as Field) * v; - low = low + (content_sha256[16 + 15 - i] as Field) * v; - v = v * 256; - } - - // Abuse that a % p + b % p = (a + b) % p and that low < p - let content = low + high * v; - content + let content_hash = sha256_to_field(hash_bytes); + content_hash } \ No newline at end of file diff --git a/yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr b/yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr index 46801de0933..32d3293e60c 100644 --- a/yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr +++ b/yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr @@ -1,7 +1,6 @@ // docs:start:token_all // docs:start:imports mod types; -mod util; // Minimal token implementation that supports `AuthWit` accounts. // The auth message follows a similar pattern to the cross-chain message and includes a designated caller. @@ -23,6 +22,7 @@ contract Token { utils as note_utils, }, context::{PrivateContext, PublicContext, Context}, + hash::{compute_message_hash}, state_vars::{map::Map, public_state::PublicState, set::Set}, types::type_serialization::{ field_serialization::{FieldSerializationMethods, FIELD_SERIALIZED_LEN}, @@ -40,7 +40,6 @@ contract Token { balances_map::{BalancesMap}, safe_u120_serialization::{SafeU120SerializationMethods, SAFE_U120_SERIALIZED_LEN} }; - use crate::util::{compute_message_hash}; // docs:end::imports // docs:start:storage_struct @@ -454,4 +453,4 @@ contract Token { } // docs:end:compute_note_hash_and_nullifier } -// docs:end:token_all +// docs:end:token_all \ No newline at end of file diff --git a/yarn-project/noir-contracts/src/contracts/token_contract/src/types/transparent_note.nr b/yarn-project/noir-contracts/src/contracts/token_contract/src/types/transparent_note.nr index ae32796f2bd..bce35b24660 100644 --- a/yarn-project/noir-contracts/src/contracts/token_contract/src/types/transparent_note.nr +++ b/yarn-project/noir-contracts/src/contracts/token_contract/src/types/transparent_note.nr @@ -1,12 +1,11 @@ // docs:start:token_types_all use dep::std::hash::pedersen; -use dep::std::hash::pedersen_with_separator; use dep::aztec::note::{ note_header::NoteHeader, note_interface::NoteInterface, utils::compute_siloed_note_hash, }; -use dep::aztec::constants_gen::GENERATOR_INDEX__L1_TO_L2_MESSAGE_SECRET; +use dep::aztec::hash::{compute_secret_hash}; global TRANSPARENT_NOTE_LEN: Field = 2; @@ -39,7 +38,7 @@ impl TransparentNote { fn new_from_secret(amount: Field, secret: Field) -> Self { TransparentNote { amount: amount, - secret_hash: TransparentNote::compute_secret_hash(secret), + secret_hash: compute_secret_hash(secret), secret: secret, header: NoteHeader::empty(), } @@ -83,13 +82,8 @@ impl TransparentNote { // CUSTOM FUNCTIONS FOR THIS NOTE TYPE - fn compute_secret_hash(secret: Field) -> Field { - // TODO(#1205) This is probably not the right index to use - pedersen_with_separator([secret], GENERATOR_INDEX__L1_TO_L2_MESSAGE_SECRET)[0] - } - fn knows_secret(self, secret: Field) { - let hash = TransparentNote::compute_secret_hash(secret); + let hash = compute_secret_hash(secret); assert(self.secret_hash == hash); } } diff --git a/yarn-project/noir-contracts/src/contracts/token_contract/src/util.nr b/yarn-project/noir-contracts/src/contracts/token_contract/src/util.nr deleted file mode 100644 index 701d0dd0527..00000000000 --- a/yarn-project/noir-contracts/src/contracts/token_contract/src/util.nr +++ /dev/null @@ -1,10 +0,0 @@ -// docs:start:token_util_all -use dep::std::hash::{pedersen_with_separator}; -use dep::aztec::constants_gen::GENERATOR_INDEX__SIGNATURE_PAYLOAD; - -fn compute_message_hash(args: [Field; N]) -> Field { - // @todo @lherskind We should probably use a separate generator for this, - // to avoid any potential collisions with payloads. - pedersen_with_separator(args, GENERATOR_INDEX__SIGNATURE_PAYLOAD)[0] -} -// docs:end:token_util_all \ No newline at end of file diff --git a/yarn-project/noir-contracts/src/contracts/uniswap_contract/src/main.nr b/yarn-project/noir-contracts/src/contracts/uniswap_contract/src/main.nr index 2b01f224802..e92dd734d17 100644 --- a/yarn-project/noir-contracts/src/contracts/uniswap_contract/src/main.nr +++ b/yarn-project/noir-contracts/src/contracts/uniswap_contract/src/main.nr @@ -8,6 +8,7 @@ contract Uniswap { use dep::aztec::{ auth::{IS_VALID_SELECTOR, assert_valid_public_message_for}, context::{PrivateContext, PublicContext, Context}, + hash::compute_message_hash, oracle::compute_selector::compute_selector, oracle::context::get_portal_address, state_vars::{map::Map, public_state::PublicState}, @@ -21,7 +22,7 @@ contract Uniswap { }; use crate::interfaces::{Token, TokenBridge}; - use crate::util::{compute_message_hash, compute_swap_private_content_hash, compute_swap_public_content_hash}; + use crate::util::{compute_swap_private_content_hash, compute_swap_public_content_hash}; struct Storage { // like with account contracts, stores the approval message on a slot and tracks if they are active diff --git a/yarn-project/noir-contracts/src/contracts/uniswap_contract/src/util.nr b/yarn-project/noir-contracts/src/contracts/uniswap_contract/src/util.nr index 4e578587e4a..8d51e11679b 100644 --- a/yarn-project/noir-contracts/src/contracts/uniswap_contract/src/util.nr +++ b/yarn-project/noir-contracts/src/contracts/uniswap_contract/src/util.nr @@ -1,11 +1,4 @@ -use dep::std::hash::{pedersen_with_separator, sha256}; -use dep::aztec::constants_gen::GENERATOR_INDEX__SIGNATURE_PAYLOAD; - -fn compute_message_hash(args: [Field; N]) -> Field { - // @todo @lherskind We should probably use a separate generator for this, - // to avoid any potential collisions with payloads. - pedersen_with_separator(args, GENERATOR_INDEX__SIGNATURE_PAYLOAD)[0] -} +use dep::aztec::hash::sha256_to_field; // This method computes the L2 to L1 message content hash for the private // refer `l1-contracts/test/portals/UniswapPortal.sol` on how L2 to L1 message is expected @@ -52,23 +45,7 @@ fn compute_swap_private_content_hash( hash_bytes[i + 260] = canceller_bytes[i]; hash_bytes[i + 292] = caller_on_L1_bytes[i]; } - - let content_sha256 = sha256(hash_bytes); - - // Convert the content_sha256 to a field element - let mut v = 1; - let mut high = 0 as Field; - let mut low = 0 as Field; - - for i in 0..16 { - high = high + (content_sha256[15 - i] as Field) * v; - low = low + (content_sha256[16 + 15 - i] as Field) * v; - v = v * 256; - } - - // Abuse that a % p + b % p = (a + b) % p and that low < p - let content_hash = low + high * v; - + let content_hash = sha256_to_field(hash_bytes); content_hash } @@ -118,21 +95,6 @@ fn compute_swap_public_content_hash( hash_bytes[i + 292] = caller_on_L1_bytes[i]; } - let content_sha256 = sha256(hash_bytes); - - // Convert the content_sha256 to a field element - let mut v = 1; - let mut high = 0 as Field; - let mut low = 0 as Field; - - for i in 0..16 { - high = high + (content_sha256[15 - i] as Field) * v; - low = low + (content_sha256[16 + 15 - i] as Field) * v; - v = v * 256; - } - - // Abuse that a % p + b % p = (a + b) % p and that low < p - let content_hash = low + high * v; - + let content_hash = sha256_to_field(hash_bytes); content_hash } From 1073bcd742dda8be92f86a46bbab77df19704277 Mon Sep 17 00:00:00 2001 From: Rahul Kothari Date: Mon, 2 Oct 2023 13:38:23 +0100 Subject: [PATCH 4/4] fix(master): remove secret_hash ref (#2617) A recent commit to master included another reference to `compute_secret_hash` which I had moved in my PR but rebase didn't catch it in time. --- .../noir-contracts/src/contracts/token_contract/src/main.nr | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr b/yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr index 32d3293e60c..a100c701794 100644 --- a/yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr +++ b/yarn-project/noir-contracts/src/contracts/token_contract/src/main.nr @@ -22,7 +22,7 @@ contract Token { utils as note_utils, }, context::{PrivateContext, PublicContext, Context}, - hash::{compute_message_hash}, + hash::{compute_message_hash, compute_secret_hash}, state_vars::{map::Map, public_state::PublicState, set::Set}, types::type_serialization::{ field_serialization::{FieldSerializationMethods, FIELD_SERIALIZED_LEN}, @@ -274,7 +274,7 @@ contract Token { secret: Field, ) -> Field { let pending_shields = storage.pending_shields; - let secret_hash = TransparentNote::compute_secret_hash(secret); + let secret_hash = compute_secret_hash(secret); let options = NoteGetterOptions::new().select(0, amount).select(1, secret_hash).set_limit(1); let notes = pending_shields.get_notes(options); let note = notes[0].unwrap_unchecked();